---
title: "Lovable Cloud zu Supabase: Was nach dem Umzug kaputtgeht"
description: "Ich stellte einen Lovable-Export in einem neuen Supabase-Projekt wieder her. Der einfache Restore: 539 Fehler, alle Daten da, weitere Grants, Sessions weg."
url: "https://madsalt.tech/de/blog/lovable-cloud-to-supabase-what-breaks/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/de/about/"
language: "de"
published: 2026-11-08
---

# Lovable Cloud zu Supabase: Was nach dem Umzug kaputtgeht

Kurz gesagt

Lovable kann ein Cloud-Projekt nicht in einem Schritt in Ihr eigenes Supabase verschieben: Sie stellen den Datenbankexport wieder her und verschieben Dateien, Secrets und Anmeldeeinstellungen von Hand. Ich habe Export und Restore auf einem lokalen Supabase-Stack mit einer erfundenen App wiederholt. Ein einfaches `pg_restore` meldete 539 Fehler und lud trotzdem jede Zeile, es sah also in Ordnung aus, gab aber der öffentlichen Rolle `anon` TRUNCATE auf jeder Tabelle, verlor die Sessions der Nutzer und den geplanten Job und ließ die Anmeldeeinstellungen auf den Standardwerten. Stellen Sie die Struktur aus Ihren Migrationen her, danach nur die Daten, und führen Sie die Prüfungen unten aus, bevor Sie die App umschalten.

Ich bin Denys, Full-Stack- und KI-Entwickler. Die meisten Anleitungen zum Verlassen von Lovable Cloud enden, wenn der Restore-Befehl fertig ist. Diese beginnt dort: wie das neue Projekt danach aussieht und was Sie prüfen müssen, bevor echte Nutzer darauf landen.

Ich habe das nicht auf Lovables Servern ausgeführt. Ich habe ein kleines fiktives SaaS auf einem lokalen Supabase-Stack gebaut (CLI 2.109.1, Postgres 17.6): drei Tabellen mit RLS und Policies, eine View, eine `SECURITY DEFINER`-Funktion, ausdrückliche Grants, ein privater Bucket mit zwei Dateien, zwei Nutzer, ein geplanter Job, eine Realtime-Tabelle, strengere Anmeldeeinstellungen und ein Funktions-Secret. Dann habe ich es in dem Format exportiert, das Lovable für seinen Export dokumentiert, und zweimal in ein frisches Projekt wiederhergestellt.

## Lässt sich ein Lovable-Cloud-Projekt mit einem Klick zu Supabase verschieben?

Nein, Stand 6. November 2026 nicht. [Lovables Dokumentation](https://docs.lovable.dev/features/database-backups) sagt, es "überträgt ein Projekt nicht in einem Schritt auf ein anderes Backend": Sie exportieren die Datenbank, laden die Storage-Dateien herunter, verschieben den Code per Git-Sync und richten Authentifizierung, Secrets, Umgebungsvariablen und externe Dienste neu ein. [Supabases eigene Troubleshooting-Seite](https://supabase.com/docs/guides/troubleshooting/cant-access-supabase-project-lovable-cloud) bestätigt das: Es gibt keinen automatisierten Weg, ein Lovable-Cloud-Projekt auf Ihr Supabase-Konto zu übertragen. Der Ablauf "claim your project", von dem Sie gelesen haben könnten, gehört zum Plattformangebot von Supabase für App-Builder; Lovables Dokumentation bietet ihn für Cloud-Projekte nicht an.

## Was steckt im Export, und was nicht?

Laut derselben Dokumentation enthält der Export die ganze Datenbank, Struktur und Daten, einschließlich der Nutzerkonten und ihrer Passwort-Hashes, die Nutzer behalten also ihre Passwörter. Er enthält keine Dateien im Storage, keinen Code von Edge Functions, keine Secrets, keine Einstellungen der Anmeldeanbieter und keine API-Keys des Projekts. Es ist ein komprimiertes PostgreSQL-Archiv für `pg_restore`, begrenzt auf Datenbanken bis 15 GB, eine Datei von 5 GB und einen Export alle 24 Stunden.

Mein Export der Test-App, erstellt mit `pg_dump -Fc --compress=zstd`, war 333 KB groß und enthielt weit mehr als meine drei Tabellen: Supabases eigene Schemas `auth`, `storage`, `realtime`, `vault`, `extensions` und weitere kamen mit. Das macht den einfachen Restore so laut.

## Was passierte bei der einfachen Wiederherstellung?

![Ein Export, zwei Wege zur Wiederherstellung. Erfundene App auf einem lokalen Supabase-Stack, CLI 2.109.1, Postgres 17.6. Einfaches pg_restore: 539 Fehler → Zeilen komplett → Grants weiter, Sessions weg; Erst Migrationen, dann Daten: Schema ok → Daten, 3 Mal → wie die Quelle; Storage-Dateien: Zeilen da → Dateien fehlen → von Hand laden; Anmeldeeinstellungen, Secrets: nicht drin → Standardwerte → neu setzen.](https://madsalt.tech/charts/de/lovable-cloud-to-supabase-what-breaks.svg)

*Abbildung 1. Mein Lauf, 6. November 2026. Der einfache Restore sah gut aus und war es nicht.*

In ein frisches Projekt, als Nutzer `postgres`, ohne Optionen: `pg_restore -d <database> export.dump`. Es endete mit "errors ignored on restore: 539". Die meisten betrafen Supabases interne Schemas: 91 × "grant options cannot be granted back to your own grantor", 37 × "permission denied for schema auth", 28 × "permission denied for schema storage" und viele "already exists". Leicht abzutun, denn die Daten waren da:

| Was                                             | Quell-App                                | Nach dem einfachen Restore                                    |
| ----------------------------------------------- | ---------------------------------------- | ------------------------------------------------------------- |
| Zeilen in companies / profiles / orders         | 2 / 2 / 5                                | 2 / 2 / 5                                                     |
| Nutzer, mit Passwort-Hashes                     | 2                                        | 2, und das alte Passwort funktioniert noch                    |
| Tabellen mit RLS an, Policies                   | 3 an, 6 Policies                         | 3 an, 6 Policies                                              |
| View `security_invoker`, Funktionseinstellungen | gesetzt                                  | unverändert                                                   |
| Grants für `anon`                               | keine                                    | TRUNCATE, REFERENCES, TRIGGER auf allen Tabellen und der View |
| Zusätzliche Grants für `authenticated`          | keine über select, insert, update hinaus | TRUNCATE, REFERENCES, TRIGGER                                 |
| Sessions, Identitäten, Refresh Tokens           | 2 / 2 / 2                                | 0 / 0 / 0                                                     |
| Geplanter Job                                   | 1                                        | 0                                                             |
| Dateien im Bucket                               | 2, beide ladbar                          | 2 Zeilen, Download scheitert mit HTTP 500                     |

Drei dieser Zeilen wiegen schwerer als die Fehlerzahl:

- **Die Grants wurden weiter.** Die Quell-App hatte `anon` alles entzogen und `authenticated` nur gegeben, was die Policies brauchen. Das wiederhergestellte Projekt gab beiden Rollen TRUNCATE, REFERENCES und TRIGGER auf jeder Tabelle. Soweit ich sehe, stammten sie aus den Standardrechten des neuen Projekts, und die eigenen Grant-Anweisungen des Exports gehörten zu den 539 Fehlern, sodass sie nichts zurücknahm. RLS deckt TRUNCATE nicht ab. Ich habe nicht getestet, ob jemand das über die Data API nutzen könnte, aber keine Client-Rolle braucht es, und genau das entfernt [Prüfung 6 meiner Sicherheits-Checkliste für Lovable](https://madsalt.tech/de/blog/lovable-app-security-checklist/).
- **Alle sind abgemeldet.** Die Zeilen für Sessions, Identitäten und Refresh Tokens scheiterten an Fremdschlüsseln, deshalb bekam ein vom alten Projekt ausgestelltes Access Token HTTP 403 `session_not_found`. Nutzer können sich mit ihrem alten Passwort wieder anmelden, was in meinem Lauf funktionierte; auch Lovables Dokumentation warnt vor der Abmeldung. Offen ist die Anmeldung mit Google oder GitHub: Die Tabelle `identities` verbindet so eine Anmeldung mit dem bestehenden Nutzer, und sie kam leer zurück.
- **Die Dateien sind Zeilen ohne Dateien.** `storage.objects` beschreibt jede Datei, und die Zeilen kamen mit, aber die Dateien selbst sind nicht im Export. Auf meinem lokalen Stack scheiterte der Download mit HTTP 500. Ich habe nur das lokale Storage-Backend getestet, probieren Sie also selbst einen Download im neuen gehosteten Projekt, und rechnen Sie damit, dass er scheitert, bis Sie die Dateien hochladen.

## Welcher Restore funktionierte?

Der Weg, auf den Lovables Anleitung verweist: erst die Struktur, dann die Daten. Im zweiten frischen Projekt:

1. **Struktur aus Ihren Migrationen.** Ich führte mein Schema-SQL aus, das Äquivalent des Ordners `supabase/migrations`, den Lovable mit GitHub synchronisiert. Es lief sauber durch, mit meinen Grants, Policies, der View und der Funktion genau wie in der Quelle.
2. **Nur Daten aus dem Export.** `pg_restore --data-only -d <database> export.dump` endete mit 17 Fehlern. Die meisten betrafen wieder Supabases interne Tabellen, die das neue Projekt schon hatte. Fünf nicht: `identities`, `sessions`, `refresh_tokens`, `mfa_amr_claims` und `one_time_tokens` scheiterten an Fremdschlüsseln, zum Beispiel `Key (user_id)=(…) is not present in table "users"`, weil der Daten-Restore sie vor ihren Elternzeilen lud.
3. **Die gescheiterten Tabellen noch einmal, Eltern zuerst.** Die einzelne Wiederherstellung von `auth.identities` und `auth.sessions` lud sie; ein dritter Lauf mit `auth.refresh_tokens` und `auth.mfa_amr_claims` endete mit Exit-Code 0.
4. **Der geplante Job von Hand.** Das Wiederherstellen der `cron`-Daten wurde verweigert ("permission denied for table job"), also legte ich den Job mit `cron.schedule` neu an. Sein Ausführungsverlauf kommt nicht mit.

Ich habe das im lokalen Datenbank-Container ausgeführt; bei einem gehosteten Projekt ist `$NEW_DB_URL` der Verbindungsstring aus dem Connect-Dialog des neuen Projekts.

```bash
pg_restore --data-only -d "$NEW_DB_URL" export.dump
pg_restore --data-only -d "$NEW_DB_URL" -n auth -t identities -t sessions export.dump
pg_restore --data-only -d "$NEW_DB_URL" -n auth -t refresh_tokens -t mfa_amr_claims export.dump
```

Danach stimmte jede Prüfung unten mit der Quelle überein: keine Tabelle mit RLS aus, 4 öffentliche und 2 Storage-Policies, dieselben Grants Tabelle für Tabelle, die View weiter `security_invoker`, die Funktion weiter `SECURITY DEFINER` mit leerem `search_path`, die Sequenz der Bestell-ID auf dem richtigen Wert und 2 Sessions, 2 Identitäten und 2 Refresh Tokens.

Eines konnte mein Lauf nicht zeigen: Ein neues Supabase-Projekt, das nach dem 30. Mai 2026 angelegt wurde, gibt neue Tabellen nicht mehr automatisch an die Data API frei. Wenn Ihre Migrationen Tabellen ohne `GRANT` anlegen, bekommt die App im neuen Projekt den Fehler 42501, obwohl sie auf Lovable Cloud funktionierte. [Die Grant-Änderung vom 30. Oktober](https://madsalt.tech/de/blog/supabase-october-30-grant-change/) erklärt den Fehler und die Lösung.

## Was kam mit den Standardwerten zurück?

Nichts im Export trägt die Einstellungen des Projekts. Auf beiden Wegen:

| Einstellung            | Quell-App            | Neues Projekt                                  |
| ---------------------- | -------------------- | ---------------------------------------------- |
| Site URL               | die Adresse der App  | der Standard                                   |
| Erlaubte Redirect-URLs | der Callback der App | der Standard                                   |
| E-Mail-Bestätigung     | an                   | aus                                            |
| Minimale Passwortlänge | 10                   | 6, ein Passwort mit 7 Zeichen wurde akzeptiert |
| Funktions-Secret       | gesetzt              | fehlt                                          |

E-Mail-Bestätigung aus und eine kürzere Mindestlänge sind stille Rückschritte: Nichts geht kaputt, die Registrierung wird nur schwächer. Setzen Sie sie vor dem Umschalten in Authentication wieder, zusammen mit jedem Anmeldeanbieter und seiner Redirect-URL in der Konsole des Anbieters.

## Was sollten Sie vor dem Umschalten prüfen?

Führen Sie das im neuen Projekt aus und dieselben Abfragen im alten im SQL editor von Lovable (More → Database → Manage), und vergleichen Sie.

1. **Zeilenzahlen** Ihrer wichtigsten Tabellen und `select count(*) from auth.users;`.
2. **RLS und Policies.** Tabellen mit RLS aus: `select relname from pg_class c join pg_namespace n on n.oid = c.relnamespace where n.nspname = 'public' and c.relkind = 'r' and not c.relrowsecurity;` und `select count(*) from pg_policies;` auf beiden Seiten.
3. **Grants**, Tabelle für Tabelle:

```sql
select grantee, table_name, string_agg(privilege_type, ', ' order by privilege_type)
from information_schema.role_table_grants
where table_schema = 'public' and grantee in ('anon', 'authenticated')
group by grantee, table_name
order by table_name, grantee;
```

4. **Auth-Daten.** `select count(*) from auth.identities;` muss mit dem alten Projekt übereinstimmen, falls sich jemand mit Google, GitHub oder Ähnlichem anmeldet.
5. **Geplante Jobs.** `select jobname, schedule from cron.job;`
6. **Dateien.** Laden Sie pro Bucket eine Datei über die App herunter, angemeldet als ihr Besitzer.
7. **Anmeldung.** Melden Sie sich als Testnutzer mit dem alten Passwort an, registrieren Sie dann einen neuen Nutzer und prüfen Sie, dass sich die Bestätigungs-E-Mail und die Passwortregel wie zuvor verhalten.
8. **Secrets und Funktionen.** Jedes Secret, das Ihre Edge Functions lesen, ist gesetzt, und jede Funktion ist deployt.

Sobald das Projekt in Ihrem eigenen Supabase-Konto liegt, kann sich der kostenlose [Supabase-Sicherheitscheck](https://madsalt.tech/de/tools/supabase-security-check/) damit verbinden und die Konfigurationsprüfungen in einem Durchgang ausführen. Der Zwei-Nutzer-Test und die Dateien bleiben Handarbeit.

## Was braucht der Umzug noch von Hand?

- **Storage-Dateien.** Laden Sie jeden Bucket in Lovable unter More → Storage herunter und laden Sie die Dateien in Buckets mit denselben Namen hoch, damit die Pfade in `storage.objects` auf echte Dateien zeigen.
- **Secrets.** Sie werden nicht exportiert, kopieren Sie also jedes aus Lovables Secrets in die Edge-Function-Secrets des neuen Projekts.
- **Edge Functions.** Deployen Sie sie aus dem Ordner `supabase/functions` Ihres Repositorys.
- **Anmeldeanbieter und Redirect-URLs**, in Supabase und in der Konsole jedes Anbieters.
- **Die Verbindung der App.** Richten Sie sie auf die URL und den öffentlichen Key des neuen Projekts aus und lassen Sie das alte Backend laufen, bis das neue jede Prüfung oben bestanden hat.

Enthält Ihre App Kundendaten, machen Sie die Sicherheitsprüfungen im neuen Projekt vor dem Umschalten, nicht danach: Bei einem Umzug verschieben sich Grants und Policies, wie der einfache Restore zeigte. Die ganze Liste steht in meiner [Sicherheits-Checkliste für Lovable-Apps](https://madsalt.tech/de/blog/lovable-app-security-checklist/).

## Mein ähnlicher Fall

Ein Unternehmen, für das ich gebaut habe, zahlte mehrere tausend Dollar im Monat für ein Dokumentenprodukt für Großunternehmen. Die eigene Plattform kostet heute einige hundert im Monat, mit Rollen für Dokumente, Formulare, Berichte und ein Kundenportal und nur den Funktionen, die das Team nutzt. Siehe die [Fallstudie zur Bau-Dokumentenplattform](https://madsalt.tech/de/work/construction-document-platform/).

Sie ziehen von Lovable Cloud um? Schreiben Sie mir, und wir klären den Umzug, bevor etwas bricht.

Sie ziehen von Lovable Cloud um?

Schreiben Sie mir, was Sie jetzt haben und was Sie brauchen. Ich antworte mit der Option, die ich wählen würde.

[Schreiben Sie mir](https://madsalt.tech/de/#contact)
