Skip to main content

Supabase

Supabase bundles a PostgreSQL database with an Auth service, a REST API, a GraphQL API, Realtime subscriptions and file Storage behind one endpoint. Studio, the Supabase web console, is available but disabled by default because it has full access to the database. Some Supabase features are not offered; see Not offered. Availability depends on the project's infrastructure; trial organizations cannot create a Supabase instance.

Create an instance​

Open Services → Create Service → Supabase. The creation form has these sections:

  • Basic Configuration — instance name and Supabase's PostgreSQL version.
  • Resources — database compute class (eco, standard, or production) and flavor (vCPU and memory), database storage size, and file storage size for the Storage API. Sizes can only grow. Auth, REST, GraphQL, Realtime, Storage and the API gateway run a fixed footprint of 1,350 mCPU and 1,152 MiB of memory (Auth 500 mCPU, REST, Realtime and Storage 250 mCPU each, the API gateway 100 mCPU), billed at the chosen compute class's rates on top of the database price. These CPU amounts are ceilings: heavy traffic is throttled rather than scaled. Like every database pod, each component reserves exactly what it is billed for. Enabling Studio adds Studio and the database metadata service (350 mCPU and 544 MiB, at the same rates) and a 1 GiB volume on the instance's storage class. Prices follow your organization's rates. The resource summary lists the database, the components, Studio when enabled, the volumes and an estimate of backup storage, so the total cost is visible before creating the instance; the hourly figure it shows is the hourly amount invoiced.
  • API access — public HTTPS API access, enabled by default because Supabase client libraries call it directly from browsers and mobile apps, with an optional IP allow-list.
  • Studio — the web console, off by default.
  • Authentication — optional Auth settings; see Authentication.
  • Backups — scheduled snapshot configuration, enabled by default with a daily run at 02:00 UTC. The schedule can be changed; manual snapshots are always available regardless of this setting.

What's included​

  • Database — a PostgreSQL 17 database, sized by the chosen flavor. The image ships extensions such as pg_cron, pgmq, pgvector, PostGIS, wrappers, Vault and pg_net (used by database webhooks); enable one with CREATE EXTENSION or from Studio.
  • Auth — user sign-up, sign-in and session management with email and password or OAuth providers, and multi-factor authentication with TOTP authenticator apps. See Authentication.
  • REST — an automatically generated REST API over the database schema, enforcing row-level security.
  • GraphQL — a GraphQL API over the same schema.
  • Realtime — subscriptions to database changes over a WebSocket.
  • Storage — an S3-like file storage API backed by its own volume, also reachable through an S3-compatible endpoint. One upload is limited to 50 MiB by default; the limit can be raised to 5 GiB (fileStorage.maxFileSizeMiB in the API).
  • Studio — the Supabase web console. Off by default. When enabled, it is served on the same public endpoint behind its own username and password, and it has full access to the database — enable it only for trusted operators. Studio and the database metadata service it relies on run, and are billed, only while Studio is enabled. Turning Studio off deletes them together with Studio's volume, so SQL snippets saved in Studio are lost; turning it back on starts an empty Studio.

Not offered​

  • Image transformations (imgproxy).
  • A connection pooler (Supavisor).
  • Public database access. The database is reachable only from the project: from containers and jobs through DATABASE_URL, or from Studio's SQL editor.
  • Custom domains.
  • Phone and SMS sign-in, SAML single sign-on, auth hooks, CAPTCHA, custom email templates and anonymous sign-ins.
  • Studio's AI assistant and log explorer.
  • Edge Functions — run custom logic in a container or job instead.
  • Supabase's own analytics — use SailOps logs, metrics and alerts.

Authentication​

Auth settings are optional. Set them in the Authentication section of the form, or through the auth object of the API; they can be changed after creation. Changing a setting restarts Auth, and the instance reports Updating until it is ready again.

  • Site URL — the HTTPS address of your application, used as the default redirect after sign-in and in emails. Defaults to the instance's public endpoint.
  • Redirect URLs — up to 20 additional URLs a sign-in may redirect to. Globs such as https://*.example.com/** are accepted.
  • Disable sign-ups — refuses new accounts; existing users can still sign in. On by default: anyone holding the publishable key could otherwise create an account, confirmed immediately while no SMTP server is set.
  • SMTP — host, port (587 by default), username, password, sender address and sender name of the mail server Auth sends emails through.
  • OAuth providers — a client ID and a client secret per provider: Google, GitHub, GitLab, Bitbucket, Discord, Facebook, Apple, LinkedIn (OIDC), Slack (OIDC), Twitch, Spotify, Notion, Zoom, X and Figma.
Without SMTP, no email is sent

Until an SMTP server is configured, Auth sends no email at all: no confirmation, no password reset, no magic link and no invitation. New email accounts are confirmed automatically. Once SMTP is set, new accounts must confirm their address.

For an OAuth provider, register <public endpoint>/auth/v1/callback as the redirect URI in the provider's console. The provider sends users' browsers to that URL, so OAuth sign-in requires public access. Providers that also need their own server URL, such as Azure, Keycloak and WorkOS, are not offered.

The SMTP password and the provider secrets are write-only: they are never returned, only whether one is stored. An update that omits a secret keeps the stored one. An empty SMTP password removes the stored password; a provider secret is removed by removing the provider. A restored instance keeps the source's Auth settings, secrets included, but it has a new hostname: register its <public endpoint>/auth/v1/callback at each OAuth provider.

Public endpoint​

Public access is on by default. When enabled, only the API paths are exposed on the public endpoint: Auth, REST, GraphQL, Realtime and Storage. Studio and the internal metadata API are never reachable through the public endpoint unless Studio is explicitly enabled, at which point they are served on the same hostname behind Studio's own credentials. An optional CIDR allow-list restricts which client addresses may reach the public endpoint; an empty list allows every address.

REST, GraphQL, Realtime and the Auth API require an API key. Storage enforces its own access rules: files in public buckets and signed URLs are readable without a key. The Auth paths a browser opens directly (/auth/v1/verify, /auth/v1/callback, /auth/v1/authorize), /.well-known/* and /sso/saml/* are open by design.

Credentials​

The Credentials tab and the credentials API always return:

  • the API endpoint, the publishable key (safe to ship to browsers; subject to row-level security) and the secret key (bypasses row-level security, server-side only), plus their legacy JWT equivalents, the anon key and the service role key, for clients that predate the new keys;
  • the database host, port (5432), database name (postgres) and user (postgres), reachable only from the project;
  • the Storage API's S3 endpoint (<endpoint>/storage/v1/s3), region, access key ID and secret access key. These S3 keys grant full access to every bucket; keep them server-side.

The Studio password and the database password are each shown only once, the first time credentials are read after the instance is created or after a reset. A later read returns everything except these two passwords.

Resetting credentials regenerates the Studio password and the database password and returns them once; it never rotates the API keys, since rotating them would break every connected client immediately. During a reset, the instance restarts its components to pick up the new password, which takes about one to two minutes; the instance reports Updating during that window.

Connect containers and jobs​

Create a connection from a container or job and select the Supabase instance. The access level chosen for the connection controls which credentials are injected:

  • Read-only — the API endpoint and the publishable key, enough for a client that only calls the REST, GraphQL or Realtime APIs under row-level security.
  • Read/write and full — the same, plus the secret key and a direct PostgreSQL connection string, for server-side code that needs to bypass row-level security or query the database directly.

Backups and restore​

Scheduled backups snapshot the database volume and the file storage volume together, daily at 02:00 UTC by default; the schedule is configurable and can be disabled, in which case manual snapshots remain available. Scheduled backups are kept for seven days; manual backups are kept until deleted.

Backups are billed as backup storage, on the size of the volumes they hold. Scheduled backups are kept seven days, so the resource summary counts the scheduled runs the schedule makes in seven days (at least one), plus one manual backup: eight with the default daily schedule. It estimates backup storage as that count × (database storage + file storage) × the backup storage price per GiB and month. This is an estimate: the invoice follows the backups that actually exist. A pruned or deleted backup stops being billed.

Restoring a backup always creates a new instance rather than overwriting the source. The restored instance keeps the source instance's API keys and Auth settings, so applications already configured with those keys keep working against the restored instance without any code change. Fields left unset in a restore request inherit the source instance's configuration, and sizes can only be as large or larger than the source's — never smaller.

Resizing​

Database and file storage volumes can only grow, never shrink. The storage class chosen at creation is fixed for the life of the instance. The database compute class and flavor can be changed after creation.

Suspension​

When a project is suspended, the Supabase instance's compute stops being billed and its public endpoint is closed, but the underlying database keeps running so the platform can resume it reliably. Storage remains billed while suspended. Resuming the project restores public access once every component is ready again.

Logs, metrics and alerts​

The Logs tab filters by component (database, Auth, REST, Realtime, Storage, the API gateway, and the metadata service and Studio while Studio is enabled). The Observability tab shows CPU, memory and storage usage over time, using the same dashboard as other services. Alerts are raised at the pod level for the instance, the same way as for other managed databases.

Limits​

  • One database per instance — Supabase does not offer point-in-time recovery; only the scheduled and manual snapshots above.
  • Deleting an instance deletes its database and its stored files. Its backups are not deleted with it; they remain available for restore into a new instance until you delete them explicitly.
  • Trial organizations cannot create a Supabase instance.