---
title: "Crediti Run di Lovable: cosa li consuma e come trovarlo"
description: "Cosa conta Lovable come crediti Run, perché un'app ferma può consumare più di una attiva e le ricerche SQL e nel codice che trovano il job o il loop."
url: "https://madsalt.tech/it/blog/lovable-run-credits/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-07
---

# Crediti Run di Lovable: cosa li consuma e come trovarlo

In breve

I crediti Run pagano la sua app pubblicata: database, calcolo, rete, storage, realtime e chiamate di IA. La causa solita di un'impennata è qualcosa che non si ferma mai: un job pianificato ogni pochi secondi, un timer di polling, una pagina che si ricarica da sola. Nel resoconto di un builder, un job di email ogni 5 secondi ha fatto costare a un progetto di prova vuoto 1,86 crediti al giorno, mentre il prodotto vero ne costava 0,15. Apra More → Usage, elenchi i suoi job con l'SQL qui sotto, cerchi i timer nel codice e imposti un limite di utilizzo di Cloud prima della prossima sorpresa.

Sono Denys, ingegnere full-stack e di IA. Quando qualcuno mi affida un'app Lovable, la bolletta è spesso la prima domanda, prima della sicurezza. Non ho mai pagato una bolletta di Lovable Cloud di mio, quindi i numeri qui vengono dalla documentazione di Lovable, letta il 6 novembre 2026, e da builder che hanno pubblicato i loro.

## Cosa conta come credito Run?

Lovable ha un solo saldo di crediti. Costruire e chattare appare come crediti Build; tutto ciò che consuma la sua app pubblicata appare come crediti Run. Dalla [documentazione di Lovable sull'utilizzo del progetto](https://docs.lovable.dev/features/project-usage):

| Categoria | Cosa paga                                                                                     |
| --------- | --------------------------------------------------------------------------------------------- |
| Database  | Il server del database (dimensione dell'istanza, quanto resta attivo, query) e il suo storage |
| Compute   | Il codice che gira dietro le quinte: edge function, pagamenti, email                          |
| Network   | I dati che l'app invia e riceve: risposte API, upload, immagini                               |
| Storage   | I file che l'app conserva, anche mentre il progetto è in pausa                                |
| Realtime  | Gli aggiornamenti in diretta: messaggi di chat, notifiche, modifiche collaborative            |
| AI        | Le funzioni di IA dentro la sua app, per modello                                              |

Free, Pro e Business includono ciascuno una dotazione mensile di Cloud di 20 crediti, che Lovable definisce un'offerta temporanea, e [un credito Pro costa 0,25 USD](https://docs.lovable.dev/introduction/subscription-plans) nel livello da 100 crediti. Venti crediti al mese sono circa 0,67 al giorno. Un progetto che resta sotto questa soglia non costa nulla in più; uno che resta attivo tutto il giorno di solito sì.

## Cosa ha fatto salire i crediti Run in progetti reali?

![Crediti Run al giorno, due progetti di un builder. Lovable Cloud, come riportato su r/lovable, 29 giugno 2026. Progetto di prova, job email ogni 5 secondi: 1,86; Dotazione mensile Cloud, al giorno: 0,67; Progetto di produzione con utenti reali: 0,15.](https://madsalt.tech/charts/it/lovable-run-credits.svg)

*I numeri dell'autore. La dotazione mensile di Cloud di 20 crediti, dalla documentazione di Lovable, è mostrata al giorno.*

Tre resoconti da r/lovable, ciascuno con i numeri dell'autore:

- **Un job di email ogni 5 secondi.** Un builder aveva due progetti su Lovable Cloud. Il progetto di sviluppo, con un database minuscolo e quasi nessun traffico, usava circa 1,86 crediti Run al giorno; quello di produzione ne usava 0,15. La causa, trovata insieme al team di Lovable, era un job in background della coda email che girava ogni 5 secondi e apriva ogni volta una connessione al database, anche senza niente da inviare, così il database non andava mai a riposo. A quel ritmo il progetto vuoto avrebbe usato circa 56 crediti al mese, quasi il triplo della dotazione mensile. ([r/lovable, 29 giugno 2026](https://www.reddit.com/r/lovable/comments/1uifjbq/lovable_run_credits_almost_made_me_abandon_the/))
- **Il 95% di database fin dal primo giorno.** Un altro builder ha usato 6,54 crediti Run nelle prime 24 ore, il 95% di database, ed è tornato a controllare i suoi job pianificati. ([r/lovable, 19 giugno 2026](https://www.reddit.com/r/lovable/comments/1u9xtvj/price_of_run_credits_seems_twice_as_expensive_to/))
- **Un loop di ricarica in una sola scheda.** Un'app privata, una scheda del browser bloccata in un loop di ricarica e rendering, più di 3 milioni di richieste e 1 milione di richieste al database, e circa 4.000 USD di addebiti in circa due ore, secondo il conto dell'autore. Nessun picco di traffico e nessun attacco. ([r/lovable, 9 giugno 2026](https://www.reddit.com/r/lovable/comments/1u0pfz8/how_my_private_lovable_app_generated_a_4000_bill/))

Lo schema è lo stesso in tutti e tre: il costo non veniva dagli utenti. Veniva da qualcosa che gira da solo e non si ferma mai.

## Come si trova ciò che consuma i crediti?

Parta dal controllo più economico e vada verso il più lento.

1. **Apra la vista Usage.** Nel progetto, More → Usage, filtri per Run credits. La ripartizione sotto il grafico è ordinata per categoria. Database in cima su un progetto tranquillo indica qualcosa che lo tiene sveglio; Network o Compute in cima indicano l'app o una funzione che chiama troppo spesso.
2. **Chieda a Lovable.** La documentazione di Lovable suggerisce di chiedere nella chat del progetto che cosa genera il consumo, e mostra un pulsante Optimize your usage quando un progetto ha usato più di 5 crediti Run in 7 giorni. Consideri la risposta una pista e la confermi con i controlli qui sotto.
3. **Elenchi i job pianificati.** More → Database → Manage → Jobs li mostra, oppure esegua questo nell'editor SQL:

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

Una pianificazione come `5 seconds` o `* * * * *` (ogni minuto) è il primo sospettato. Per vedere quante volte ogni job è davvero girato nell'ultima ora:

```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;
```

Ho eseguito tutte e quattro le query di questo elenco su uno stack Supabase locale (CLI 2.109.1, Postgres 17.6). Un job di prova pianificato ogni `5 seconds` aveva già girato 17 volte circa 82 secondi dopo averlo creato, quindi una pianificazione in secondi esiste davvero ed è facile da non vedere.

4. **Trovi le query eseguite più spesso.** I progetti Supabase tengono le statistiche delle query in `pg_stat_statements`. L'istruzione con milioni di chiamate di solito è il loop:

```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. **Controlli cosa passa su Realtime.** Ogni tabella di questa publication invia le modifiche a ogni client iscritto:

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

6. **Cerchi nel codice.** Sincronizzi il progetto con GitHub o lo scarichi, poi cerchi timer e ricariche:

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

## Quali schemi di codice costano denaro?

| Schema                                                                | Perché costa                                                               | Correzione                                                                           |
| --------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| Un job pianificato ogni pochi secondi che controlla una coda          | Il database non va mai a riposo, quindi viene fatturato tutto il giorno    | Avvii il lavoro quando la riga viene scritta, oppure esegua il job ogni pochi minuti |
| `setInterval` o `refetchInterval` che interroga il database           | Ogni scheda aperta invia una richiesta ogni pochi secondi, tutto il giorno | Usi Realtime per le modifiche, oppure interroghi solo mentre la scheda è visibile    |
| Un `useEffect` senza elenco di dipendenze che carica dati             | Gira dopo ogni render, e un render può avviare il caricamento successivo   | Gli dia le dipendenze che servono e provi con la scheda network aperta               |
| `location.reload()` in un gestore di errore o di autenticazione       | Una sola richiesta fallita può ricaricare la pagina all'infinito           | Mostri l'errore invece, e limiti i tentativi                                         |
| Un abbonamento Realtime a un'intera tabella                           | Ogni modifica viene inviata a ogni iscritto                                | Filtri il canale per utente o azienda e pubblichi solo le tabelle che servono        |
| Una chiamata costosa al caricamento della pagina (IA, un'API esterna) | Ogni visitatore e ogni aggiornamento la paga                               | Metta il risultato in cache, oppure la esegua alla pressione di un pulsante          |

## Come si mette un tetto alla spesa?

Sui piani a pagamento, proprietari e admin del workspace possono impostare dei limiti sotto Workspace settings → Usage limits & alerts. Un limite di utilizzo sui crediti Cloud può avvisarla o mettere in pausa Cloud per i progetti che copre, e un avviso di saldo basso la avverte prima che il workspace finisca i crediti ([documentazione di Lovable](https://docs.lovable.dev/features/usage-limits-and-alerts)). Imposti prima un avviso, poi un limite che mette in pausa a un livello a cui preferisce mettere l'app offline piuttosto che pagare. Un backend in pausa significa un'app rotta, quindi il limite è un fusibile, non una correzione.

Tre cose che non abbassano i crediti Run: scrivere meno prompt (quelli sono crediti Build), un'istanza più grande (costa di più all'ora) e mettere in pausa un progetto che conserva molti file (lo storage continua a contare anche in pausa).

## Cosa controllare dopo una correzione?

Osservi la vista Usage per due o tre giorni. Un job o un loop corretto si vede come un calo nella barra giornaliera della categoria che sospettava; se non cala, la causa è altrove. Se il progetto è una copia di prova che nessuno usa, mettere in pausa il suo database da More → Database → Manage → Settings è la correzione più semplice di tutte.

La stessa abitudine, controllare cosa gira davvero invece di cosa dice il codice, è il cuore della mia [checklist di sicurezza per app Lovable](https://madsalt.tech/it/blog/lovable-app-security-checklist/). Se la sua app è lenta oltre che costosa, le query del punto 4 sono da dove parto in un [recupero di progetto](https://madsalt.tech/it/services/project-rescue/).

Vedi anche: [Ridurre i costi dell'AI: 9 modi che funzionano nel 2026](https://madsalt.tech/it/blog/how-to-reduce-ai-costs/).

## Il mio caso simile

Il mio lavoro si regge su controlli dei costi come questi: Claude o Codex orchestra, modelli gratuiti su OpenRouter fanno la maggior parte del lavoro, e cambio il livello di effort da un compito all'altro invece di lasciarlo alto.

I crediti o le fatture AI crescono ogni mese? Mi scriva cosa paga e vedremo dove può costare meno.

La sua fattura AI cresce ogni mese?

Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.

[Mi scriva](https://madsalt.tech/it/#contact)
