---
title: "Run credits do Lovable: o que os gasta e como descobrir"
description: "O que o Lovable conta como Run credits, por que uma app parada pode gastar mais que uma ativa e como encontrar a tarefa ou o ciclo com SQL e código."
url: "https://madsalt.tech/pt/blog/lovable-run-credits/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-07
---

# Run credits do Lovable: o que os gasta e como descobrir

Em resumo

Os Run credits pagam a sua app publicada: base de dados, computação, rede, armazenamento, realtime e chamadas de IA. A causa habitual de um salto é algo que nunca pára: uma tarefa agendada de poucos em poucos segundos, um temporizador de polling, uma página que se recarrega sozinha. No relato de um builder, uma tarefa de email de 5 em 5 segundos fez um projeto de teste vazio custar 1,86 créditos por dia, enquanto o produto real custava 0,15. Abra More → Usage, liste as suas tarefas com o SQL abaixo, procure temporizadores no código e defina um limite de utilização do Cloud antes da próxima surpresa.

Sou o Denys, engenheiro full-stack e de IA. Quando alguém me entrega uma app Lovable, a fatura é muitas vezes a primeira pergunta, antes da segurança. Nunca paguei uma fatura do Lovable Cloud por conta própria, por isso os números aqui vêm da documentação do Lovable, lida a 6 de novembro de 2026, e de builders que publicaram os seus.

## O que conta como Run credit?

O Lovable tem um único saldo de créditos. Construir e conversar aparece como Build credits; tudo o que a sua app publicada consome aparece como Run credits. Da [documentação do Lovable sobre a utilização do projeto](https://docs.lovable.dev/features/project-usage):

| Categoria | O que paga                                                                                                      |
| --------- | --------------------------------------------------------------------------------------------------------------- |
| Database  | O servidor da base de dados (tamanho da instância, quanto tempo fica acordado, consultas) e o seu armazenamento |
| Compute   | O código que corre nos bastidores: edge functions, pagamentos, emails                                           |
| Network   | Os dados que a app envia e recebe: respostas da API, uploads, imagens                                           |
| Storage   | Os ficheiros que a app guarda, mesmo com o projeto em pausa                                                     |
| Realtime  | As atualizações em direto: mensagens de chat, notificações, edições colaborativas                               |
| AI        | As funcionalidades de IA dentro da sua app, por modelo                                                          |

Os planos Free, Pro e Business incluem cada um uma dotação mensal de Cloud de 20 créditos, que o Lovable descreve como uma oferta temporária, e [um crédito Pro custa 0,25 USD](https://docs.lovable.dev/introduction/subscription-plans) no escalão de 100 créditos. Vinte créditos por mês são cerca de 0,67 por dia. Um projeto que fica abaixo disso não custa nada a mais; um que fica acordado o dia todo costuma custar.

## O que fez disparar os Run credits em projetos reais?

![Run credits por dia, dois projetos de um builder. Lovable Cloud, segundo o r/lovable, 29 de junho de 2026. Projeto de teste, tarefa de email a cada 5 segundos: 1,86; Dotação mensal do Cloud, por dia: 0,67; Projeto de produção com utilizadores reais: 0,15.](https://madsalt.tech/charts/pt/lovable-run-credits.svg)

*Os números do próprio autor. A dotação mensal de Cloud de 20 créditos, da documentação do Lovable, é mostrada por dia.*

Três relatos do r/lovable, cada um com os números do próprio autor:

- **Uma tarefa de email de 5 em 5 segundos.** Um builder tinha dois projetos no Lovable Cloud. O projeto de desenvolvimento, com uma base de dados minúscula e quase sem tráfego, usava cerca de 1,86 Run credits por dia; o de produção usava 0,15. A causa, descoberta com a equipa do Lovable, era uma tarefa em segundo plano da fila de emails que corria de 5 em 5 segundos e abria uma ligação à base de dados de cada vez, mesmo sem nada para enviar, por isso a base de dados nunca ficava inativa. A esse ritmo, o projeto vazio gastaria cerca de 56 créditos por mês, quase o triplo da dotação mensal. ([r/lovable, 29 de junho de 2026](https://www.reddit.com/r/lovable/comments/1uifjbq/lovable_run_credits_almost_made_me_abandon_the/))
- **95% de base de dados no primeiro dia.** Outro builder gastou 6,54 Run credits nas primeiras 24 horas, 95% deles em base de dados, e voltou a verificar as suas tarefas agendadas. ([r/lovable, 19 de junho de 2026](https://www.reddit.com/r/lovable/comments/1u9xtvj/price_of_run_credits_seems_twice_as_expensive_to/))
- **Um ciclo de recarga num só separador.** Uma app privada, um separador do browser preso num ciclo de recarga e nova renderização, mais de 3 milhões de pedidos e 1 milhão de pedidos à base de dados, e cerca de 4000 USD em cobranças em cerca de duas horas, pela conta do autor. Sem pico de tráfego e sem ataque. ([r/lovable, 9 de junho de 2026](https://www.reddit.com/r/lovable/comments/1u0pfz8/how_my_private_lovable_app_generated_a_4000_bill/))

O padrão é o mesmo nos três: o custo não veio dos utilizadores. Veio de algo que corre sozinho e nunca pára.

## Como descobrir o que está a gastar créditos?

Comece pela verificação mais barata e vá até à mais lenta.

1. **Abra a vista Usage.** No projeto, More → Usage, filtre por Run credits. A discriminação abaixo do gráfico está ordenada por categoria. Database no topo num projeto calmo aponta para algo que o mantém acordado; Network ou Compute no topo apontam para a app ou para uma função que chama demasiado.
2. **Pergunte ao Lovable.** A documentação do Lovable sugere perguntar no chat do projeto o que causa o consumo, e mostra um botão Optimize your usage quando um projeto gastou mais de 5 Run credits em 7 dias. Trate a resposta como uma pista e confirme-a com as verificações abaixo.
3. **Liste as tarefas agendadas.** More → Database → Manage → Jobs mostra-as, ou execute isto no editor SQL:

```sql
select jobid, jobname, schedule, active, left(command, 80) as command
from cron.job
order by jobid;
```

Um agendamento como `5 seconds` ou `* * * * *` (todos os minutos) é o primeiro suspeito. Para ver quantas vezes cada tarefa correu mesmo na última hora:

```sql
select j.jobname, count(*) as runs_last_hour
from cron.job_run_details d
join cron.job j using (jobid)
where d.start_time > now() - interval '1 hour'
group by j.jobname
order by runs_last_hour desc;
```

Executei as quatro consultas desta lista numa stack Supabase local (CLI 2.109.1, Postgres 17.6). Uma tarefa de teste agendada a cada `5 seconds` já tinha corrido 17 vezes cerca de 82 segundos depois de a criar, por isso um agendamento em segundos existe mesmo e é fácil de não ver.

4. **Encontre as consultas que correm mais vezes.** Os projetos Supabase guardam estatísticas de consultas em `pg_stat_statements`. A instrução com milhões de chamadas costuma ser o ciclo:

```sql
select calls, round(total_exec_time) as total_ms, left(query, 100) as query
from extensions.pg_stat_statements
order by calls desc
limit 10;
```

5. **Veja o que circula pelo Realtime.** Cada tabela desta publicação envia as alterações a todos os clientes subscritos:

```sql
select schemaname, tablename
from pg_publication_tables
where pubname = 'supabase_realtime';
```

6. **Pesquise no código.** Sincronize o projeto com o GitHub ou descarregue-o e depois procure temporizadores e recargas:

```bash
grep -rnE "setInterval|refetchInterval|location\.reload|\.channel\(" src supabase
```

## Que padrões de código custam dinheiro?

| Padrão                                                           | Por que custa                                                                        | Correção                                                                                   |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ |
| Uma tarefa agendada de poucos em poucos segundos que vê uma fila | A base de dados nunca fica inativa, por isso é cobrada o dia todo                    | Dispare o trabalho quando a linha é escrita, ou corra a tarefa de poucos em poucos minutos |
| `setInterval` ou `refetchInterval` que consulta a base de dados  | Cada separador aberto envia um pedido de poucos em poucos segundos, o dia todo       | Use o Realtime para as alterações, ou consulte só enquanto o separador estiver visível     |
| Um `useEffect` sem lista de dependências que vai buscar dados    | Corre depois de cada renderização, e uma renderização pode disparar a busca seguinte | Dê-lhe as dependências de que precisa e teste com o separador de rede aberto               |
| `location.reload()` num tratador de erro ou de autenticação      | Um só pedido falhado pode recarregar a página para sempre                            | Mostre o erro em vez disso e limite as tentativas                                          |
| Uma subscrição Realtime a uma tabela inteira                     | Cada alteração é enviada a cada subscritor                                           | Filtre o canal por utilizador ou empresa e publique só as tabelas de que precisa           |
| Uma chamada cara no carregamento da página (IA, uma API externa) | Cada visitante e cada atualização pagam por ela                                      | Guarde o resultado em cache, ou execute-a ao premir um botão                               |

## Como pôr um teto?

Nos planos pagos, os proprietários e administradores do workspace podem definir limites em Workspace settings → Usage limits & alerts. Um limite de utilização nos créditos Cloud pode avisá-lo ou pôr o Cloud em pausa nos projetos que abrange, e um alerta de saldo baixo avisa-o antes de o workspace ficar sem créditos ([documentação do Lovable](https://docs.lovable.dev/features/usage-limits-and-alerts)). Defina primeiro um alerta, depois um limite que pause, num nível em que prefira pôr a app offline a pagar. Um backend em pausa significa uma app avariada, por isso o limite é um fusível, não uma correção.

Três coisas que não baixam os Run credits: escrever menos prompts (esses são Build credits), uma instância maior (custa mais por hora) e pôr em pausa um projeto que guarda muitos ficheiros (o armazenamento continua a contar em pausa).

## O que verificar depois de uma correção?

Acompanhe a vista Usage durante dois ou três dias. Uma tarefa ou um ciclo corrigido nota-se numa queda na barra diária da categoria que suspeitava; se não baixar, a causa está noutro lado. Se o projeto é uma cópia de teste que ninguém usa, pôr a sua base de dados em pausa em More → Database → Manage → Settings é a correção mais simples de todas.

O mesmo hábito, verificar o que realmente corre em vez do que o código diz, é o centro da minha [lista de segurança para apps Lovable](https://madsalt.tech/pt/blog/lovable-app-security-checklist/). Se a sua app é lenta além de cara, as consultas do passo 4 são por onde começo num [resgate de projeto](https://madsalt.tech/pt/services/project-rescue/).

Ver também: [Reduzir custos de IA: 9 formas que funcionam em 2026](https://madsalt.tech/pt/blog/how-to-reduce-ai-costs/).

## O meu caso semelhante

O meu próprio trabalho funciona com controlos de custo como estes: o Claude ou o Codex orquestra, modelos gratuitos na OpenRouter fazem a maior parte do trabalho, e mudo o nível de esforço de tarefa para tarefa em vez de o deixar alto.

Os créditos ou as faturas de IA crescem todos os meses? Escreva-me o que paga e vemos onde pode custar menos.

A sua fatura de IA cresce todos os meses?

Diga-me o que tem agora e o que precisa. Respondo com a opção que eu escolheria.

[Fale comigo](https://madsalt.tech/pt/#contact)
