---
title: "Lovable Run credits: årsaker og hvordan du finner dem"
description: "Hva Lovable teller som Run credits, hvorfor en rolig app kan bruke mer enn en travel, og SQL- og kodesøkene som finner jobben eller løkken bak regningen."
url: "https://madsalt.tech/no/blog/lovable-run-credits/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/no/about/"
language: "no"
published: 2026-11-07
---

# Lovable Run credits: årsaker og hvordan du finner dem

TL;DR

Run credits betaler for den publiserte appen din: database, beregning, nettverk, lagring, realtime og AI-kall. Den vanlige årsaken til et hopp er noe som aldri stopper: en planlagt jobb hvert par sekunder, en polling-timer, en side som laster seg selv på nytt. I én utviklers rapport kostet et tomt testprosjekt 1,86 credits om dagen på grunn av en e-postjobb hvert 5. sekund, mens det ekte produktet kostet 0,15. Åpne More → Usage, list jobbene dine med SQL-en under, søk i koden etter timere, og sett en Cloud-bruksgrense før neste overraskelse.

Jeg er Denys, fullstack- og AI-ingeniør. Når noen gir meg en Lovable-app, er regningen ofte det første spørsmålet, foran sikkerhet. Jeg har ikke selv betalt en Lovable Cloud-regning, så tallene her kommer fra Lovables dokumentasjon, lest 6. november 2026, og fra utviklere som har publisert sine.

## Hva teller som en Run credit?

Lovable har én enkelt kredittsaldo. Å bygge og chatte vises som Build credits; alt den publiserte appen din bruker, vises som Run credits. Fra [Lovables dokumentasjon om prosjektbruk](https://docs.lovable.dev/features/project-usage):

| Kategori | Hva den betaler for                                                                        |
| -------- | ------------------------------------------------------------------------------------------ |
| Database | Databaseserveren (instansstørrelse, hvor lenge den er våken, spørringer) og lagringen dens |
| Compute  | Kode som kjører i bakgrunnen: edge functions, betalinger, e-post                           |
| Network  | Data appen sender og mottar: API-svar, opplastinger, bilder                                |
| Storage  | Filer appen lagrer, også mens prosjektet er satt på pause                                  |
| Realtime | Live-oppdateringer: chatmeldinger, varsler, samtidig redigering                            |
| AI       | AI-funksjoner i appen din, per modell                                                      |

Free, Pro og Business inkluderer hver en månedlig Cloud-tildeling på 20 credits, som Lovable kaller et midlertidig tilbud, og [en Pro-credit koster 0,25 USD](https://docs.lovable.dev/introduction/subscription-plans) på nivået med 100 credits. Tjue credits i måneden er omtrent 0,67 om dagen. Et prosjekt som holder seg under, koster ingenting ekstra; et som er våkent hele dagen, gjør det vanligvis.

## Hva fikk Run credits til å skyte i været i ekte prosjekter?

![Run credits per dag, to prosjekter fra én utvikler. Lovable Cloud, etter en rapport på r/lovable, 29. juni 2026. Testprosjekt, e-postjobb hvert 5. sekund: 1,86; Månedlig Cloud-tildeling, per dag: 0,67; Produksjonsprosjekt med ekte brukere: 0,15.](https://madsalt.tech/charts/no/lovable-run-credits.svg)

*Forfatterens egne tall. Den månedlige Cloud-tildelingen på 20 credits, fra Lovables dokumentasjon, vises per dag.*

Tre rapporter fra r/lovable, hver med forfatterens egne tall:

- **En e-postjobb hvert 5. sekund.** En utvikler hadde to prosjekter på Lovable Cloud. Utviklingsprosjektet, med en liten database og nesten ingen trafikk, brukte omtrent 1,86 Run credits om dagen; produksjonsprosjektet 0,15. Årsaken, funnet sammen med Lovables team, var en e-postkø-jobb i bakgrunnen som kjørte hvert 5. sekund og åpnet en databaseforbindelse hver gang, selv uten noe å sende, så databasen aldri ble ledig. Med den takten ville det tomme prosjektet brukt omtrent 56 credits i måneden, nesten tre ganger den månedlige tildelingen. ([r/lovable, 29. juni 2026](https://www.reddit.com/r/lovable/comments/1uifjbq/lovable_run_credits_almost_made_me_abandon_the/))
- **95 % database første dag.** En annen utvikler brukte 6,54 Run credits de første 24 timene, 95 % av dem database, og gikk tilbake for å sjekke de planlagte jobbene sine. ([r/lovable, 19. juni 2026](https://www.reddit.com/r/lovable/comments/1u9xtvj/price_of_run_credits_seems_twice_as_expensive_to/))
- **En reload-løkke i én fane.** En privat app, én nettleserfane som satt fast i en løkke av omlasting og ny rendering, mer enn 3 millioner forespørsler og 1 million databaseforespørsler, og omtrent 4 000 USD i kostnader på rundt to timer, etter forfatterens telling. Ingen trafikktopp og ikke noe angrep. ([r/lovable, 9. juni 2026](https://www.reddit.com/r/lovable/comments/1u0pfz8/how_my_private_lovable_app_generated_a_4000_bill/))

Mønsteret er det samme i alle tre: kostnaden kom ikke fra brukerne. Den kom fra noe som kjører av seg selv og aldri stopper.

## Hvordan finner du det som brenner credits?

Gå fra den billigste sjekken til den tregeste.

1. **Åpne Usage-visningen.** I prosjektet, More → Usage, filtrer på Run credits. Oversikten under diagrammet er sortert etter kategori. Database øverst i et stille prosjekt peker på noe som holder den våken; Network eller Compute øverst peker på appen eller en funksjon som kaller for ofte.
2. **Spør Lovable.** Lovables dokumentasjon foreslår å spørre i prosjektchatten hva som driver bruken, og viser en Optimize your usage-knapp når et prosjekt har brukt mer enn 5 Run credits på 7 dager. Behandle svaret som et spor og bekreft det med sjekkene under.
3. **List de planlagte jobbene.** More → Database → Manage → Jobs viser dem, eller kjør dette i SQL editor:

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

Et tidsskjema som `5 seconds` eller `* * * * *` (hvert minutt) er første mistenkte. Slik ser du hvor ofte hver jobb faktisk kjørte den siste timen:

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

Jeg kjørte alle fire spørringene i denne listen på en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6). En testjobb planlagt hvert `5 seconds` hadde allerede kjørt 17 ganger omtrent 82 sekunder etter at jeg opprettet den, så et tidsskjema i sekunder er reelt og lett å overse.

4. **Finn spørringene som kjører oftest.** Supabase-prosjekter har spørringsstatistikk i `pg_stat_statements`. Setningen med millioner av kall er vanligvis løkken:

```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. **Sjekk hva som strømmer over Realtime.** Hver tabell i denne publikasjonen sender endringer til hver abonnerende klient:

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

6. **Søk i koden.** Synkroniser prosjektet til GitHub eller last det ned, og søk så etter timere og omlastinger:

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

## Hvilke kodemønstre koster penger?

| Mønster                                                    | Hvorfor det koster                                                        | Løsning                                                                           |
| ---------------------------------------------------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| En planlagt jobb hvert par sekunder som sjekker en kø      | Databasen blir aldri ledig, så den faktureres hele dagen                  | Utløs arbeidet når raden skrives, eller kjør jobben hvert par minutter            |
| `setInterval` eller `refetchInterval` som poller databasen | Hver åpne fane sender en forespørsel hvert par sekunder, hele dagen       | Bruk Realtime for endringer, eller poll bare mens fanen er synlig                 |
| En `useEffect` uten avhengighetsliste som henter data      | Den kjører etter hver rendering, og en rendering kan utløse neste henting | Gi den avhengighetene den trenger, og test med nettverksfanen åpen                |
| `location.reload()` i en feil- eller auth-handler          | Én mislykket forespørsel kan laste siden på nytt for alltid               | Vis feilen i stedet, og begrens antall nye forsøk                                 |
| Et Realtime-abonnement på en hel tabell                    | Hver endring sendes til hver abonnent                                     | Filtrer kanalen etter bruker eller selskap, og publiser bare tabellene du trenger |
| Et dyrt kall ved sidelasting (AI, et eksternt API)         | Hver besøkende og hver oppdatering betaler for det                        | Mellomlagre resultatet, eller kjør det på et knappetrykk                          |

## Hvordan setter du et tak?

På betalte planer kan workspace-eiere og administratorer sette grenser under Workspace settings → Usage limits & alerts. En bruksgrense på Cloud-credits kan varsle deg eller sette Cloud på pause for prosjektene den dekker, og et varsel om lav saldo advarer deg før workspacet går tomt ([Lovables dokumentasjon](https://docs.lovable.dev/features/usage-limits-and-alerts)). Sett først et varsel, deretter en grense som setter på pause, på et nivå der du heller tar appen offline enn å betale. En backend på pause betyr en ødelagt app, så grensen er en sikring, ikke en løsning.

Tre ting som ikke senker Run credits: å skrive færre prompter (det er Build credits), en større instans (den koster mer per time) og å sette et prosjekt med mange filer på pause (lagringen teller videre mens det er på pause).

## Hva bør du sjekke etter en rettelse?

Følg med på Usage-visningen i to–tre dager. En rettet jobb eller løkke viser seg som et fall i den daglige søylen for kategorien du mistenkte; hvis den ikke faller, ligger årsaken et annet sted. Hvis prosjektet er en testkopi ingen bruker, er det enkleste av alt å sette databasen på pause fra More → Database → Manage → Settings.

Den samme vanen, å sjekke hva som faktisk kjører i stedet for hva koden sier, er kjernen i [sikkerhetssjekklisten min for Lovable-apper](https://madsalt.tech/no/blog/lovable-app-security-checklist/). Hvis appen din er treg i tillegg til dyr, er spørringene fra steg 4 der jeg starter i en [prosjektredning](https://madsalt.tech/no/services/project-rescue/).

Se også: [Redusere AI-kostnader: 9 grep som virker i 2026](https://madsalt.tech/no/blog/how-to-reduce-ai-costs/).

## Mitt tilsvarende tilfelle

Mitt eget arbeid kjører på kostnadskontroller som disse: Claude eller Codex orkestrerer, gratis modeller på OpenRouter gjør hoveddelen av arbeidet, og jeg endrer effort-nivået fra oppgave til oppgave i stedet for å la det stå på høy.

Vokser kreditter eller AI-regninger hver måned? Skriv til meg med hva du betaler, så finner vi ut hvor det kan koste mindre.

Vokser AI-regningen din hver måned?

Fortell meg hva du har nå og hva du trenger. Jeg svarer med alternativet jeg selv ville valgt.

[Skriv til meg](https://madsalt.tech/no/#contact)
