---
title: "Lovable Run credits: vad som bränner dem"
description: "Vad Lovable räknar som Run credits, varför en overksam app kan förbruka mer än en upptagen, och sökningarna som hittar loopen bakom fakturan."
url: "https://madsalt.tech/sv/blog/lovable-run-credits/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/sv/about/"
language: "sv"
published: 2026-11-07
---

# Lovable Run credits: vad som bränner dem

Kort sagt

Run credits betalar för din publicerade app: databas, beräkning, nätverk, lagring, realtid och AI-anrop. Den vanliga orsaken till ett hopp är något som aldrig slutar: ett schemalagt jobb med några sekunders mellanrum, en pollningstimer eller en sida som laddar om sig själv. I en byggares rapport fick ett e-postjobb var 5:e sekund ett tomt testprojekt att kosta 1,86 krediter om dagen medan den riktiga produkten kostade 0,15. Öppna More → Usage, lista dina jobb med SQL:en nedan, sök i koden efter timers och sätt en Cloud-användningsgräns före nästa överraskning.

Jag heter Denys och är full-stack- och AI-ingenjör. När någon lämnar över en Lovable-app är fakturan ofta den första frågan, före säkerheten. Jag har inte själv betalat någon Lovable Cloud-faktura, så siffrorna här kommer från Lovables dokumentation, läst den 6 november 2026, och från byggare som publicerat sina egna.

## Vad räknas som Run credits?

Lovable har ett enda kreditsaldo. Byggande och chatt visas som Build credits; allt som din publicerade app förbrukar visas som Run credits. Från [Lovables dokumentation om projektanvändning](https://docs.lovable.dev/features/project-usage):

| Kategori | Vad den betalar för                                                              |
| -------- | -------------------------------------------------------------------------------- |
| Database | Databasservern (instansstorlek, hur länge den är vaken, frågor) och dess lagring |
| Compute  | Kod som körs i bakgrunden: edge functions, betalningar, e-post                   |
| Network  | Data som appen skickar och tar emot: API-svar, uppladdningar, bilder             |
| Storage  | Filer som appen lagrar, även medan projektet är pausat                           |
| Realtime | Liveuppdateringar: chattmeddelanden, notiser, gemensamma redigeringar            |
| AI       | AI-funktioner i din app, per modell                                              |

Free, Pro och Business inkluderar var och en ett månatligt Cloud-bidrag på 20 krediter, som Lovable kallar ett tillfälligt erbjudande, och [en Pro-kredit kostar 0,25 USD](https://docs.lovable.dev/introduction/subscription-plans) på 100-kreditsnivån. Tjugo krediter i månaden är ungefär 0,67 om dagen. Ett projekt som håller sig under det kostar ingenting extra; ett som är vaket hela dagen gör det oftast.

## Vad fick Run credits att rusa i verkliga projekt?

![Run credits per dag, två projekt hos en byggare. Lovable Cloud, rapporterat på r/lovable, 29 juni 2026. Testprojekt, e-postjobb var 5:e sekund: 1,86; Månatligt Cloud-bidrag, per dag: 0,67; Produktionsprojekt med riktiga användare: 0,15.](https://madsalt.tech/charts/sv/lovable-run-credits.svg)

*Författarens egna siffror. Det månatliga Cloud-bidraget på 20 krediter, från Lovables dokumentation, visas per dag.*

Tre rapporter från r/lovable, var och en med författarens egna siffror:

- **Ett e-postjobb var 5:e sekund.** En byggare hade två projekt på Lovable Cloud. Utvecklingsprojektet, med en liten databas och nästan ingen trafik, använde omkring 1,86 Run credits om dagen; produktionsprojektet 0,15. Orsaken, som hittades tillsammans med Lovables team, var ett bakgrundsjobb för en e-postkö som kördes var 5:e sekund och öppnade en databasanslutning varje gång, även när det inte fanns något att skicka, så databasen blev aldrig overksam. I den takten skulle det tomma projektet använda omkring 56 krediter i månaden, nästan tre gånger det månatliga bidraget. ([r/lovable, 29 juni 2026](https://www.reddit.com/r/lovable/comments/1uifjbq/lovable_run_credits_almost_made_me_abandon_the/))
- **95 % databas första dagen.** En annan byggare förbrukade 6,54 Run credits under de första 24 timmarna, 95 % av det databas, och gick tillbaka för att kontrollera sina schemalagda jobb. ([r/lovable, 19 juni 2026](https://www.reddit.com/r/lovable/comments/1u9xtvj/price_of_run_credits_seems_twice_as_expensive_to/))
- **En omladdningsloop i en flik.** En privat app, en webbläsarflik fastnad i en loop av omladdning och omrendering, mer än 3 miljoner förfrågningar och 1 miljon databasförfrågningar, och omkring 4 000 USD i avgifter på ungefär två timmar, enligt författarens egen uppgift. Ingen trafiktopp och ingen attack. ([r/lovable, 9 juni 2026](https://www.reddit.com/r/lovable/comments/1u0pfz8/how_my_private_lovable_app_generated_a_4000_bill/))

Mönstret är detsamma i alla tre: kostnaden kom inte från användare. Den kom från något som körs av sig självt och aldrig stannar.

## Hur hittar du vad som bränner krediter?

Arbeta från den billigaste kontrollen till den långsammaste.

1. **Öppna Usage-vyn.** I projektet, More → Usage, filtrera på Run credits. Uppdelningen under diagrammet är sorterad per kategori. Databas överst i ett lugnt projekt pekar på något som håller den vaken; Network eller Compute överst pekar på appen eller en funktion som anropar för ofta.
2. **Fråga Lovable.** Lovables dokumentation föreslår att du frågar i projektets chatt vad som driver användningen, och visar en Optimize your usage-knapp när ett projekt har förbrukat mer än 5 Run credits på 7 dagar. Behandla svaret som en ledtråd och bekräfta det med kontrollerna nedan.
3. **Lista de schemalagda jobben.** More → Database → Manage → Jobs visar dem, eller kör det här i SQL editor:

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

Ett schema som `5 seconds` eller `* * * * *` (varje minut) är den första misstänkta. Så här ser du hur ofta varje jobb faktiskt kördes den senaste timmen:

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

Jag körde alla fyra frågorna i den här listan på en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6). Ett testjobb schemalagt var `5 seconds` hade redan körts 17 gånger ungefär 82 sekunder efter att jag skapade det, så ett schema i sekunder är verkligt och lätt att missa.

4. **Hitta de frågor som körs oftast.** Supabase-projekt sparar frågestatistik i `pg_stat_statements`. Satsen med miljontals anrop är oftast loopen:

```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. **Kontrollera vad som strömmar över Realtime.** Varje tabell i den här publikationen skickar ändringar till varje prenumererande klient:

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

6. **Sök i koden.** Synka projektet till GitHub eller ladda ner det och sök sedan efter timers och omladdningar:

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

## Vilka kodmönster kostar pengar?

| Mönster                                                                  | Varför det kostar                                                               | Åtgärd                                                                                 |
| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| Ett schemalagt jobb med några sekunders mellanrum som kontrollerar en kö | Databasen blir aldrig overksam, så den faktureras hela dagen                    | Starta arbetet när raden skrivs, eller kör jobbet med några minuters mellanrum         |
| `setInterval` eller `refetchInterval` som pollar databasen               | Varje öppen flik skickar en förfrågan med några sekunders mellanrum, hela dagen | Använd Realtime för ändringar, eller polla bara medan fliken syns                      |
| En `useEffect` utan beroendelista som hämtar data                        | Den körs efter varje rendering, och en rendering kan utlösa nästa hämtning      | Ge den de beroenden den behöver, och testa med nätverksfliken öppen                    |
| `location.reload()` i en fel- eller autentiseringshanterare              | En enda misslyckad förfrågan kan ladda om sidan i evighet                       | Visa felet i stället och begränsa antalet omförsök                                     |
| En Realtime-prenumeration på en hel tabell                               | Varje ändring skickas till varje prenumerant                                    | Filtrera kanalen per användare eller företag och publicera bara de tabeller du behöver |
| Ett dyrt anrop vid sidladdning (AI, ett externt API)                     | Varje besökare och varje uppdatering betalar för det                            | Cacha resultatet, eller kör det vid ett knapptryck                                     |

## Hur sätter du ett tak?

På betalda planer kan arbetsytans ägare och administratörer sätta gränser under Workspace settings → Usage limits & alerts. En användningsgräns för Cloud-krediter kan meddela dig eller pausa Cloud för de projekt den omfattar, och en varning för lågt saldo varnar innan arbetsytan får slut på krediter ([Lovables dokumentation](https://docs.lovable.dev/features/usage-limits-and-alerts)). Sätt en varning först, sedan en pausande gräns på en nivå där du hellre tar appen offline än betalar. En pausad backend betyder en trasig app, så gränsen är en säkring, inte en åtgärd.

Tre saker som inte sänker Run credits: att skriva färre prompter (de är Build credits), en större instans (den kostar mer per timme) och att pausa ett projekt som lagrar många filer (lagringen räknas vidare medan det är pausat).

## Vad bör du kontrollera efter en åtgärd?

Följ Usage-vyn i två eller tre dagar. Ett åtgärdat jobb eller en åtgärdad loop syns som ett fall i dagsstapeln för den kategori du misstänkte; om den inte faller ligger orsaken någon annanstans. Om projektet är en testkopia som ingen använder är det enklaste av allt att pausa dess databas från More → Database → Manage → Settings.

Samma vana, att kontrollera vad som faktiskt körs i stället för vad koden säger, är kärnan i min [säkerhetschecklista för Lovable-appar](https://madsalt.tech/sv/blog/lovable-app-security-checklist/). Om din app är långsam och dyr är frågorna från steg 4 det jag börjar med i en [projekträddning](https://madsalt.tech/sv/services/project-rescue/).

Se även: [Minska AI-kostnader: 9 sätt som fungerar 2026](https://madsalt.tech/sv/blog/how-to-reduce-ai-costs/).

## Mitt liknande fall

Mitt eget arbete går på kostnadskontroller som dessa: Claude eller Codex orkestrerar, gratismodeller på OpenRouter gör merparten av arbetet, och jag ändrar effort-nivån från uppgift till uppgift i stället för att låta den stå på hög.

Växer krediter eller AI-räkningar varje månad? Skriv till mig med vad du betalar, så tar vi reda på var det kan kosta mindre.

Växer din AI-räkning varje månad?

Berätta vad du har nu och vad du behöver. Jag svarar med det alternativ jag själv skulle välja.

[Skriv till mig](https://madsalt.tech/sv/#contact)
