Umsetzung

Nutzer sperren in Supabase: ban_duration, Sessions und Moderation

Supabase kann Nutzer mit einem einzigen Admin-Aufruf sperren. Damit die Sperre auch dort greift, wo noch ein gültiges Access-Token unterwegs ist, braucht es zwei, drei Ergänzungen in Edge Functions und Row Level Security.

  • Stand: Oktober 2026
  • Aktualisiert am
  • 5 Min. Lesezeit

Dieser Ratgeber zeigt, wie du Nutzer in Supabase sperrst, warum die Sperre nicht überall sofort wirkt und wie du das schließt. Er funktioniert ohne Limenia. Was Limenia abnehmen kann, steht im letzten Abschnitt.

ban_duration in der Auth Admin API

Supabase Auth speichert für jeden Nutzer ein banned_until. Du setzt es über die Admin-API mit ban_duration, im JavaScript-Client mit auth.admin.updateUserById. Der Aufruf gehört in eine Edge Function oder ein anderes Backend, denn er braucht einen Secret Key.

import { createClient } from "npm:@supabase/supabase-js@2";

// Edge Functions bekommen alle Secret Keys des Projekts nach Namen, hier den Key "moderation"
const secretKeys = JSON.parse(Deno.env.get("SUPABASE_SECRET_KEYS")!);
const admin = createClient(Deno.env.get("SUPABASE_URL")!, secretKeys["moderation"], {
  auth: { persistSession: false, autoRefreshToken: false },
});

async function setBan(userId: string, banDuration: string) {
  const { error } = await admin.auth.admin.updateUserById(userId, { ban_duration: banDuration });
  if (error) throw error;
}

// dauerhaft: rund 100 Jahre
await setBan(userId, "876000h");

// auf Zeit, bis zu einem Zeitpunkt
const seconds = Math.ceil((until.getTime() - Date.now()) / 1000);
await setBan(userId, `${seconds}s`);

// aufheben
await setBan(userId, "none");

Die drei Fälle:

Fall ban_duration Was passiert
Dauerhafte Sperre 876000h banned_until liegt rund 100 Jahre in der Zukunft
Sperre auf Zeit Dauer wie 72h oder 259200s Die Sperre endet von selbst, du musst nichts planen
Sperre aufheben none banned_until wird gelöscht

Die Dauer folgt dem Format von Go: Zahlen mit den Einheiten ns, us (oder µs), ms, s, m und h, auch kombiniert wie 2h45m. Eine Einheit für Tage gibt es nicht.

Lösch gesperrte Nutzer nicht. Hat eine Beschwerde Erfolg, musst du die Sperre aufheben können, und das geht nur, solange das Konto existiert.

Warum der Ban nicht sofort alle Sessions beendet

Supabase prüft die Sperre an drei Stellen sofort: bei der Anmeldung, beim Token-Refresh und bei Aufrufen an Supabase Auth selbst, etwa getUser(). Der Refresh scheitert mit „Invalid Refresh Token: User Banned“, die Anmeldung mit dem Fehlercode user_banned.

Was nicht sofort stoppt, ist ein schon ausgestelltes Access-Token. Es ist ein signiertes JWT und gilt bis zu seinem Ablauf, im Standard eine Stunde. Bis dahin akzeptieren die Datenbank-API, Storage und Realtime es weiter, und Row Level Security sieht nur auth.uid(), nicht die Sperre. Eine Session per Nutzer-ID beenden kann Supabase nicht: auth.admin.signOut erwartet das JWT der Session, nicht die Nutzer-ID.

Für die meisten Apps ist eine Stunde Nachlauf vertretbar. Bei Belästigung im Chat oder Spam-Wellen eher nicht. Dann helfen die nächsten beiden Abschnitte.

getUser() statt getClaims() oder kürzere JWT-Laufzeit

In Edge Functions hast du zwei Wege, den Nutzer zum Token zu bestimmen:

  • getClaims() prüft das JWT bei asymmetrischen Signaturschlüsseln lokal gegen die JWKS deines Projekts. Das ist schnell, sieht aber keine Sperre, solange das Token gültig ist.
  • getUser() fragt bei jedem Aufruf den Auth-Server. Für gesperrte Nutzer antwortet er mit einem Fehler.

Für Aktionen, die eine Sperre sofort stoppen soll (posten, Nachrichten schicken, melden), nimm getUser():

import { createClient } from "npm:@supabase/supabase-js@2";

const publishableKeys = JSON.parse(Deno.env.get("SUPABASE_PUBLISHABLE_KEYS")!);
const supabase = createClient(Deno.env.get("SUPABASE_URL")!, publishableKeys["default"]);

Deno.serve(async (req) => {
  const token = req.headers.get("Authorization")?.replace(/^Bearer\s+/i, "");
  if (!token) return new Response("Unauthorized", { status: 401 });

  const { data, error } = await supabase.auth.getUser(token);
  if (error || !data.user) return new Response("Forbidden", { status: 403 }); // auch bei Sperre

  // ... Aktion für data.user.id
  return new Response(null, { status: 204 });
});

Für direkte Datenbank-Zugriffe aus der App ergänzt du eine restriktive Policy. Sie wird mit allen anderen Policies per UND verknüpft. Die Funktion liegt in einem Schema, das die Datenbank-API nicht ausliefert, weil sie als security definer läuft:

create schema if not exists private;

create or replace function private.is_banned()
returns boolean
language sql
stable
security definer
set search_path = ''
as $$
  select coalesce(
    (select u.banned_until > now() from auth.users u where u.id = auth.uid()),
    false
  );
$$;

grant usage on schema private to authenticated;
revoke execute on function private.is_banned() from public, anon;
grant execute on function private.is_banned() to authenticated;

create policy "banned users cannot post"
on public.posts
as restrictive
for insert
to authenticated
with check (not (select private.is_banned()));

Das (select …) um den Funktionsaufruf lässt Postgres das Ergebnis einmal pro Abfrage berechnen statt pro Zeile. Dieselbe Policy kannst du für update, für Nachrichten und für Storage-Buckets anlegen.

Die dritte Möglichkeit: die Laufzeit der Access-Tokens verkürzen, in den Auth-Einstellungen unter Sessions. Supabase empfiehlt mindestens fünf Minuten. Kürzere Tokens bedeuten mehr Refreshs und schließen die Lücke nur teilweise.

Eigener Secret Key statt service_role

Supabase hat neue API-Keys eingeführt: Publishable Keys (sb_publishable_…) für die App und Secret Keys (sb_secret_…) für das Backend. Die alten Keys anon und service_role laufen laut Supabase-Doku bis Ende 2026 aus.

Für Sperren aus einer Edge Function heißt das:

  1. Leg im Dashboard unter API Keys einen eigenen Secret Key an, etwa mit dem Namen moderation.
  2. In gehosteten Edge Functions steht er automatisch in SUPABASE_SECRET_KEYS, einem JSON-Objekt nach Namen. Du liest ihn mit JSON.parse(Deno.env.get("SUPABASE_SECRET_KEYS")!)["moderation"], wie im Code oben.
  3. Nutze ihn nur in den Functions, die die Admin-API brauchen.

Ein eigener Key lässt sich einzeln löschen, wenn er kompromittiert ist, ohne andere Dienste zu treffen. Wichtig bleibt: Secret Keys umgehen jede RLS-Policy. Sie gehören nie in die Flutter-App, nie in Remote Config und nie in Git. Supabase lehnt Secret Keys im Browser ab, eine Mobile-App schützt das nicht.

Inhalte moderieren mit Edge Functions und Webhooks

Sperren ist das Ende des Ablaufs. Am Anfang steht die Meldung. Mit Supabase geht das ohne eigene Function, wenn RLS festlegt, wer meldet, und ein Trigger den Schnappschuss nimmt:

create table public.reports (
  id uuid primary key default gen_random_uuid(),
  reporter_id uuid not null default auth.uid() references auth.users (id),
  post_id uuid not null references public.posts (id),
  reason_category text not null check (reason_category ~ '^[a-z0-9_]{2,40}$'),
  reason_text text check (char_length(reason_text) <= 2000),
  author_id uuid,
  snapshot_text text,
  status text not null default 'open',
  created_at timestamptz not null default now(),
  unique (post_id, reporter_id)
);
alter table public.reports enable row level security;

create policy "report as yourself"
on public.reports for insert to authenticated
with check (reporter_id = (select auth.uid()) and status = 'open');

-- Schnappschuss aus der Datenbank, nicht aus der App
create or replace function private.fill_report_snapshot()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
  select p.author_id, p.content into new.author_id, new.snapshot_text
  from public.posts p where p.id = new.post_id;
  return new;
end;
$$;

create trigger reports_snapshot before insert on public.reports
for each row execute function private.fill_report_snapshot();

Ohne Select-Policy sieht niemand fremde Meldungen. Die unique-Bedingung verhindert doppelte Meldungen derselben Person.

Für den nächsten Schritt legst du einen Database Webhook auf insert in reports an. Er ruft asynchron eine Edge Function auf, die das Moderationsteam benachrichtigt oder die Meldung an ein Moderationswerkzeug weiterleitet. Gib dem Webhook einen geheimen Header mit und prüf ihn in der Function, denn die Function-URL ist öffentlich.

Nach der Entscheidung setzt eine Function die Maßnahme um: Beitrag ausblenden (status = 'removed' statt löschen), Nutzer sperren und die Begründung schicken. Nach Art. 17 DSA braucht jede Sperre und jede Entfernung eine klare und spezifische Begründung, Details im Ratgeber zur Begründung nach Art. 17 DSA. Ein gesperrter Nutzer kann sich nicht mehr anmelden. Schick die Begründung per E-Mail und zeig sie, wenn die Anmeldung mit user_banned scheitert. Wie Beschwerden gegen Sperren laufen, steht im Ratgeber zum internen Beschwerdemanagement.

Mit Limenia: Supabase-Connector

Limenia übernimmt den Teil zwischen Meldung und Maßnahme: Meldungen bündeln, im Dashboard entscheiden, Begründung nach Art. 17 erzeugen, Meldende informieren, Beschwerden annehmen. Deine Edge Function leitet Meldungen an POST /v1/reports weiter, der API-Key liegt als Function-Secret, nie in der App.

Der Supabase-Connector (Pro und Premium) setzt Sperren direkt in Supabase Auth um:

Entscheidung in Limenia In Supabase Auth
Dauerhafte Sperre ban_duration: 876000h
Sperre auf Zeit die verbleibenden Sekunden bis zum Ende, Supabase hebt sie selbst auf
Konto wiederherstellen, Ende einer Sperre ban_duration: none
Inhalt entfernen, verwarnen nichts, das läuft über den Webhook

Du legst dafür einen eigenen Secret Key nur für Limenia an. Alte service_role-Keys nimmt Limenia nicht an. An Supabase gehen nur Nutzer-UUID und Sperrdauer, Nutzer löscht Limenia nie. Voraussetzung ist, dass dein Backend die UUID aus auth.users.id als Nutzer-ID schickt.

Der Connector ändert keine Tabellen. Inhalte ausblenden und die Begründung anzeigen erledigt dein Webhook-Empfänger, und getUser() und die RLS-Policy von oben bleiben sinnvoll. Ein Beispiel mit Edge Functions liegt im Beispiel-Repo auf GitHub, Schritt für Schritt steht alles im Integrationsleitfaden unter 2.5. Für Flutter-Apps gibt es das Paket limenia auf pub.dev mit fertigen Widgets für Meldedialog, Beschwerde und Begründung. Mehr zum Connector auf Moderation für Supabase-Apps, zur App-Seite auf Moderation für Flutter-Apps.

Supabase ist eine Marke von Supabase, Inc. Flutter ist eine Marke von Google LLC.

Quellen

  1. Supabase JavaScript-Referenz: auth.admin.updateUserByIdsupabase.com
  2. Supabase JavaScript-Referenz: auth.getClaimssupabase.com
  3. Supabase: User sessionssupabase.com
  4. Supabase: Understanding API keyssupabase.com
  5. Supabase: Row Level Securitysupabase.com
  6. Supabase: Edge Function secretssupabase.com
  7. Supabase: Database Webhookssupabase.com
  8. Verordnung (EU) 2022/2065 (Digital Services Act), Art. 17 und 20, EUR-Lexeur-lex.europa.eu
  9. Limenia: Integrationsleitfaden (Abschnitt 2.5 Flutter + Supabase, 7.2 Supabase-Connector)limenia.eu
  10. Limenia: Beispiel-Backends auf GitHub (Apache 2.0)github.com

Häufige Fragen

Deine Frage ist nicht dabei? Schreib uns, wir antworten persönlich.

Zum Kontaktformular

Wie hebe ich eine Sperre in Supabase auf?

Mit updateUserById und ban_duration: "none". Eine Sperre auf Zeit läuft von selbst ab, sobald banned_until erreicht ist.

Kann ich alle Sessions eines Nutzers sofort beenden?

Nicht per Nutzer-ID. auth.admin.signOut erwartet das JWT einer Session, nicht die Nutzer-ID. Nach einer Sperre scheitert jeder Token-Refresh, ein ausgestelltes Access-Token gilt aber bis zu seinem Ablauf. Mit getUser() in Edge Functions und einer RLS-Policy auf banned_until schließt du diese Lücke.

Welche Zeiteinheiten nimmt ban_duration an?

ns, us (oder µs), ms, s, m und h, auch kombiniert wie 2h45m. Tage gibt es nicht, sieben Tage sind 168h.

Soll ich gesperrte Nutzer löschen?

Nein. Eine Löschung lässt sich nach einer erfolgreichen Beschwerde nicht zurücknehmen. Sperren lässt sich jederzeit aufheben.

Darf der Secret Key in die Flutter-App?

Nein. In die App gehört nur der Publishable Key (oder der alte anon-Key). Secret Keys umgehen Row Level Security. Supabase lehnt sie im Browser sogar ab, eine Mobile-App schützt das aber nicht.

Bereit, deine App anzubinden?

Ein REST-Aufruf hinein, ein signierter Webhook zurück. Die Anleitung für dein Backend findest du bei den Integrationen.

Oder schreib uns über das Kontaktformular