The complete technical reference for connecting your apps to Fluxbase. Covers authentication, the SQL API, OpenAI-compatible AI gateway, MCP autonomous coding agent tooling, real-time WebSockets, file storage, team management, and row-level security.
Every Fluxbase integration requires three values, found in your Project Settings:
Bearer token from Settings → API Keys. Scoped per project.
Unique project identifier visible in the URL and Settings.
https://www.fluxbasedb.me — all REST endpoints live here.
wss://fluxbase-realtime.onrender.com — for real-time events.
FLUXBASE_API_KEY=flx_live_xxxxxxxxxxxxxxxxxxxx
FLUXBASE_PROJECT_ID=51c04beb753a42f3
NEXT_PUBLIC_WS_URL=wss://fluxbase-realtime.onrender.comAll REST API requests must include an Authorization header with a valid Bearer token. Requests missing this header return 401 Unauthorized.
Authorization: Bearer flx_live_xxxxxxxxxxxxxxxxxxxx
Content-Type: application/json| Scope | Access | Recommended For |
|---|---|---|
| read | SELECT only | Dashboards, public APIs |
| write | INSERT, UPDATE, DELETE | Backend services & mutations |
| ai | Flux AI Gateway models | LLM completions, agent workflows |
| admin | Full DDL + DML access | Migration scripts, init scripts |
Fluxbase Hosting enables you to deploy full-stack Next.js applications, modern frontend frameworks (Vite, React, Vue, SvelteKit, Astro), and static web applications directly from GitHub or local archives.
To ensure deterministic, high-speed builds and zero-downtime rollouts, ensure your repository satisfies the following framework and build requirements before deploying.
Supports API route handlers, Server Actions, SSR, dynamic middleware, and background workers via Next.js Standalone containerization.
Pure frontends compiled into static bundles (out/ or dist/) and distributed across our high-performance global edge network.
In Next.js App Router (Next.js 14 and 15), Next.js automatically attempts to statically prerender (SSG) every route into an HTML file during next build.
If a page references browser globals (window, localStorage, document), dynamic search parameters (useSearchParams() without Suspense), or live database queries, the static generation pass will abort with an unhandled server error:
Error occurred prerendering page "/dashboard". Read more: https://nextjs.org/docs/messages/prerender-error
[Error: An error occurred in the Server Components render. ...] { digest: '3977694363' }
Export encountered an error on /dashboard/page: /dashboard, exiting the build.// Mark route as dynamic to skip build-time static HTML baking
export const dynamic = 'force-dynamic';
export const revalidate = 0;
export default async function DashboardPage() {
// Dynamic runtime queries, authentication checks, or cookies run cleanly on request
return <DashboardView />;
}For maximum stability and optimal containerized deployments, configure your next.config.js or next.config.ts with the following settings:
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
// Use 'standalone' for fullstack SSR (API routes, server actions, middleware)
// Use 'export' for purely client-side static SPAs without a Node backend
output: 'standalone',
// Disable server-side image optimization if deploying without specialized image proxies
images: {
unoptimized: true,
},
// Prevent minor linting warnings or strict type mismatches from failing production builds
eslint: {
ignoreDuringBuilds: true,
},
typescript: {
ignoreBuildErrors: true,
},
};
export default nextConfig;The deployment engine inspects your repository's package.json to detect your framework and execution scripts:
scripts.build is defined (e.g. "build": "next build" or "build": "vite build").devDependencies or dependencies so they are available in the build sandbox.--legacy-peer-deps.Client-side code bundled into the browser only has access to environment variables that use your framework's designated prefix:
| Framework | Client Variable Prefix | Example Variable | Backend / Secret Variables |
|---|---|---|---|
| Next.js | NEXT_PUBLIC_ | NEXT_PUBLIC_API_URL | Available in API routes / Server Actions only |
| Vite / React / Vue | VITE_ | VITE_BACKEND_URL | Inlined into client JS at build time |
| Astro | PUBLIC_ | PUBLIC_SITE_URL | Available in Astro server endpoints |
| Error in Build Log | Root Cause | Immediate Resolution |
|---|---|---|
| Error occurred prerendering page "..." | Browser API or unhandled dynamic context invoked during static build generation. | export const dynamic = 'force-dynamic'; |
| Command timed out after 600s: npm ci | Lockfile has peer dependency mismatches or is resolving thousands of conflicting packages. | Run npm install --package-lock-only or resolve conflicting peer dependencies. |
| Framework binary not found in PATH | The framework CLI (such as next or vite) is not declared in package.json. | Add the framework package directly to dependencies or devDependencies. |
| Image Optimization using Next.js default loader | Next.js <Image /> requires a live Node.js server unless unoptimized is enabled. | Add images: { unoptimized: true } to your next.config.js. |
Fluxbase includes an enterprise-grade, OpenAI-compatible AI Gateway named Flux. It enables your applications, developers, and autonomous agents to interact with our proprietary Flux AI reasoning model family across 6 distinct modalities: Text Reasoning & Chat, Image Generation, Speech-to-Text (STT), Text-to-Speech (TTS), Video Generation, and Vector Embeddings using standard OpenAI SDKs, LangChain, Cursor, Windsurf, or direct HTTP requests.
Browse all 33 models with real upstream architectures, inspect your tier's token quotas, test live in browser playground, and create scoped API keys.
All requests to /api/v1/chat/completions use these model identifiers. If omitted, the default model is flux.
| Modality | Flux Model ID | Engine Designation | Architecture | Min Tier | Capabilities & Specs |
|---|---|---|---|---|---|
| Text / Chat | flux-pro | Flux Pro | Flux Neural Cloud | Free | Frontier multimodal intelligence with deep reasoning, native vision, and fast document analysis. 300k context. |
| Text / Chat | flux-lite | Flux Lite | Flux Neural Cloud | Free | Ultra-fast multimodal reasoning, high-throughput interactive processing, sub-200ms latency. 300k context. |
| Text / Chat | flux | Flux Standard | Flux Neural Cloud | Free | Flagship default. High-accuracy general reasoning, precision SQL synthesis. 128k context. |
| Text / Chat | flux-micro | Flux Micro | Flux Neural Cloud | Free | Lowest latency text intelligence engineered for extreme throughput and real-time agents. 128k context. |
| Text / Chat | flux-turbo | Flux Turbo | Flux Neural Cloud | Free | Hyper-speed 300+ tokens/second inference. Ideal for real-time agents. 128k context. |
| Text / Chat | flux-omni | Flux Omni | Flux Neural Cloud | Free | Massive context window, multimodal vision understanding, high velocity. 300k context. |
| Text / Chat | flux-max | Flux Max | Flux Neural Cloud | Free | Flagship coding, instruction following, and vision benchmarks. 300k context. |
| Text / Chat | flux-flash | Flux Flash | Flux Neural Cloud | Free | Sub-100ms token throughput. Ideal for autocompletion, real-time UX, streaming. 128k context. |
| Text / Chat | flux-5.2 | Flux 5.2 | Flux Neural Cloud | Free | Frontier reasoning architecture engineered for multi-step agentic execution. 300k context. |
| Text / Chat | flux-ultra | Flux Ultra | Flux Neural Cloud | Free | Maximum cognitive depth for database architectural blueprints and complex migrations. 300k context. |
| Text / Chat | flux-vision | Flux Vision | Flux Neural Cloud | Free | Visual schema comprehension, diagram recognition, screenshot-to-code. 128k context. |
| Text / Chat | gpt-4o | Flux Drop-in | Flux Neural Cloud | Free | OpenAI compatibility drop-in alias automatically mapped to flux-pro. |
| Text / Chat | gpt-3.5-turbo | Flux Drop-in Mini | Flux Neural Cloud | Free | OpenAI compatibility drop-in alias automatically mapped to flux-lite. |
| Image Generation | flux-image-fast | Flux Image Fast | Flux Neural Cloud | Free | Ultra-fast low-latency image generation for avatars and thumbnails. |
| Image Generation | flux-image-ultra | Flux Image Ultra | Flux Neural Cloud | Pro | SOTA photorealism, typography rendering, and cinematic lighting with automatic S3 storage. |
| Image Generation | flux-image-hd | Flux Image HD | Flux Neural Cloud | Free | High-definition image generation with superior detail and typography. |
| Image Generation | flux-image-pro | Flux Image Pro | Flux Neural Cloud | Pro | Premium creative composition with prompt adherence and S3 storage. |
| Image Generation | flux-image | Flux Image | Flux Neural Cloud | Free | High-quality photorealistic text-to-image synthesis with automatic S3 cloud hosting. |
| Video Generation | flux-video | Flux Video | Flux Neural Cloud | Free | Text-to-video synthesis with dynamic motion and lighting (HTTP 202 async polling). |
| Video Generation | flux-video-ray | Flux Video Ray | Flux Neural Cloud | Pro | Cinema-grade video generation with realistic physics and camera motion. |
| Video Generation | flux-video-pro | Flux Video Pro | Flux Neural Cloud | Max | Cinematic high-fidelity video generation with rich motion dynamics. |
| Speech-to-Text | flux-listen | Flux Listen | Flux Neural Cloud | Free | Real-time multilingual transcription with timestamps. |
| Speech-to-Text | flux-listen-pro | Flux Listen Pro | Flux Neural Cloud | Free | Maximum precision transcription for noisy, technical audio. |
| Speech-to-Text | flux-listen-en | Flux Listen EN | Flux Neural Cloud | Free | Lightweight, hyper-fast English-only speech recognition. |
| Text-to-Speech | flux-speak | Flux Speak | Flux Neural Cloud | Free | Natural voice synthesis across multiple expressive voices. |
| Text-to-Speech | flux-speak-hd | Flux Speak HD | Flux Neural Cloud | Pro | Studio-grade high-definition audio synthesis for production voiceovers. |
| Embeddings | flux-embed | Flux Embed | Flux Neural Cloud | Free | 1024-dimensional dense vector embeddings for semantic search and RAG. |
Token throughput (TPM), request velocity (RPM), and daily generation ceilings enforced per account tier:
| Plan Tier | Text & Reasoning TPM | Requests / Min | Daily Request Limit | Image Generation | Video Synthesis |
|---|---|---|---|---|---|
| Free Tier | 10,000 TPM | 10 RPM | 500 req / day | 5 gens / day (20k TPM) | Locked (Pro/Max) |
| Pro Tier | 100,000 TPM | 60 RPM | 10,000 req / day | 50 gens / day (100k TPM) | 5 gens / day (50k TPM) |
| Max Tier | 500,000 TPM | 300 RPM | 50,000 req / day | 200 gens / day (300k TPM) | 20 gens / day (100k TPM) |
| Pay-As-You-Go / Enterprise | Unlimited (Uncapped) | Unlimited | Unlimited (Metered) | Unlimited | Unlimited |
The gateway is a 100% drop-in replacement for OpenAI. Point your client to base_url="https://www.fluxbasedb.me/api/v1" and use your Fluxbase API Key:
from openai import OpenAI
client = OpenAI(
base_url="https://www.fluxbasedb.me/api/v1",
api_key="flx_live_your_fluxbase_key"
)
# Streaming Chat Completion
stream = client.chat.completions.create(
model="flux", # or "flux-pro", "flux-ultra", "gpt-4o"
messages=[
{"role": "system", "content": "You are a database architect."},
{"role": "user", "content": "Generate an optimal indexing strategy for a high-traffic analytics table."}
],
stream=True
)
for chunk in stream:
print(chunk.choices[0].delta.content or "", end="", flush=True)| Subscription Tier | Text (RPM / TPM / Daily) | Images (Daily) | Audio (Daily) | Video (Daily) |
|---|---|---|---|---|
| Free | 10 RPM / 10k TPM / 500 req | 5 / day | 20 / day | Locked (Requires Pro) |
| Pro | 60 RPM / 100k TPM / 10k req | 50 / day | 200 / day | 5 / day |
| Max | 300 RPM / 500k TPM / 50k req | 200 / day | 1,000 / day | 20 / day |
| Employee / Org Owner / PAYG | Unlimited | Unlimited | Unlimited | Unlimited |
Fluxbase provides a built-in, native Model Context Protocol (MCP) Gateway operating over JSON-RPC 2.0. This allows AI coding assistants like Google Antigravity, Cursor, Windsurf, and Claude Desktop to inspect database schemas, run migrations, execute SQL queries, and manage projects autonomously.
create_projectPROJECTProvisions new serverless PostgreSQL or MySQL database projects.
list_projectsDISCOVERYLists all database projects owned by or shared with your account.
get_schemaSCHEMAInspects live table structures, columns, types, and primary keys.
run_sqlEXECUTEExecutes raw SQL DDL and DML statements against the tenant database.
Antigravity supports MCP natively via mcp_config.json. You can configure it either at the project level or globally across all workspaces.
Create or update .agents/mcp_config.json in your project repository root:
{
"mcpServers": {
"fluxbase": {
"serverUrl": "https://fluxbasedb.me/api/mcp",
"headers": {
"Authorization": "Bearer <YOUR_FLUXBASE_API_TOKEN>"
}
}
}
}Add the entry to your user Antigravity configuration file:
%USERPROFILE%\.gemini\config\mcp_config.json~/.gemini/config/mcp_config.jsonhttps://fluxbasedb.me/api/mcpAuthorization: Bearer <YOUR_API_TOKEN> and save.In Cursor or Windsurf, navigate to Settings → Features → MCP, click + Add New MCP Server, and configure:
{
"mcpServers": {
"fluxbase": {
"url": "https://fluxbasedb.me/api/mcp",
"headers": {
"Authorization": "Bearer <YOUR_FLUXBASE_API_TOKEN>"
}
}
}
}Open %APPDATA%\Claude\claude_desktop_config.json (or ~/Library/Application Support/Claude/claude_desktop_config.json on Mac) and add:
{
"mcpServers": {
"fluxbase": {
"url": "https://fluxbasedb.me/api/mcp",
"headers": {
"Authorization": "Bearer <YOUR_FLUXBASE_API_TOKEN>"
}
}
}
}You can test the JSON-RPC interface directly in your terminal using Node.js or curl:
node -e "fetch('https://fluxbasedb.me/api/mcp',{method:'POST',headers:{'Authorization':'Bearer <YOUR_API_TOKEN>','Content-Type':'application/json'},body:JSON.stringify({jsonrpc:'2.0',id:1,method:'tools/list'})}).then(r=>r.json()).then(d=>console.log(JSON.stringify(d,null,2)))"tools/list upon connecting.Execute any SQL statement against your project database via a single unified endpoint.
{
"projectId": "YOUR_PROJECT_ID",
"query": "SELECT * FROM users LIMIT 10;"
}{
"success": true,
"result": {
"rows": [
{ "id": 1, "name": "Alice", "email": "alice@example.com" }
],
"columns": ["id", "name", "email"],
"rowCount": 1,
"message": null
},
"executionInfo": {
"time": "11ms",
"rowCount": 1,
"operation": "SELECT"
}
}{
"success": false,
"error": {
"message": "relation "usrs" does not exist",
"code": "SQL_EXEC_ERROR",
"details": "ERROR: 42P01"
}
}success: false. Always check the success field — don't rely solely on HTTP status codes.| Field | Type | Required | Description |
|---|---|---|---|
| projectId | string | Yes | Your project's unique identifier. |
| query | string | Yes | The SQL statement to execute. Supports DDL and DML. |
| params | array | No | Optional parameterized values for $1, $2, … placeholders. |
No official SDK required — Fluxbase is a plain HTTP API. Here are copy-paste integration snippets for the most popular languages.
const BASE_URL = 'https://www.fluxbasedb.me';
const API_KEY = process.env.FLUXBASE_API_KEY;
const PROJECT = process.env.FLUXBASE_PROJECT_ID;
async function query(sql, params = []) {
const res = await fetch(`${BASE_URL}/api/execute-sql`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${API_KEY}`,
},
body: JSON.stringify({ projectId: PROJECT, query: sql, params }),
});
const json = await res.json();
if (!json.success) throw new Error(json.error?.message ?? 'Query failed');
return json.result.rows;
}
// Usage
const users = await query('SELECT id, name FROM users WHERE active = $1', [true]);
console.log(users);Fluxbase uses a persistent WebSocket connection to push live database events to connected clients. Subscribe once and receive row changes, schema updates, and custom broadcasts — with automatic reconnection.
Open one WebSocket and join a project room. All events are multiplexed over a single connection.
Get db_event messages for INSERT/UPDATE/DELETE and schema_update for DDL changes.
Built-in exponential backoff (1s → 2s → 4s → 15s max). Subscriptions restore automatically.
NEXT_PUBLIC_WS_URL=wss://fluxbase-realtime.onrender.comconst WS_URL = process.env.NEXT_PUBLIC_WS_URL ?? 'wss://fluxbase-realtime.onrender.com';
const PROJECT_ID = 'YOUR_PROJECT_ID';
let socket;
let reconnectDelay = 1000;
function connect() {
socket = new WebSocket(WS_URL);
socket.onopen = () => {
reconnectDelay = 1000; // reset on successful connection
socket.send(JSON.stringify({
type: 'subscribe',
roomId: `project_${PROJECT_ID}`,
}));
console.log('[WS] Connected and subscribed.');
};
socket.onmessage = ({ data }) => {
const msg = JSON.parse(data);
switch (msg.type) {
case 'subscribed':
console.log('[WS] Subscription confirmed.');
break;
case 'db_event': {
const { operation, table, record, old } = msg.payload ?? {};
if (operation === 'INSERT') console.log(`+ ${table}`, record);
if (operation === 'UPDATE') console.log(`~ ${table}`, { old, record });
if (operation === 'DELETE') console.log(`- ${table}`, record);
break;
}
default:
if (msg.payload?.event_type === 'schema_update') {
console.log('[WS] Schema changed — refresh your table list.');
}
}
};
socket.onclose = () => {
console.warn(`[WS] Disconnected. Reconnecting in ${reconnectDelay}ms...`);
setTimeout(connect, reconnectDelay);
reconnectDelay = Math.min(reconnectDelay * 2, 15000);
};
socket.onerror = (err) => console.error('[WS] Error:', err);
}
connect();| msg.type | payload details | When it fires |
|---|---|---|
| subscribed | — | Server confirmed room subscription. |
| db_event | operation: INSERT | A row was inserted via SQL or Table Editor. |
| db_event | operation: UPDATE | A row was modified. |
| db_event | operation: DELETE | A row was removed. |
| db_event | event_type: schema_update | DDL executed (CREATE / DROP / ALTER / RENAME / TRUNCATE). |
Secure AWS S3-backed file storage with logically isolated buckets, private-by-default access, and short-lived pre-signed URLs.
| Method | Endpoint | Action |
|---|---|---|
| GET | /api/storage/buckets?projectId=… | List all buckets + total size |
| POST | /api/storage/buckets | Create a bucket |
| PATCH | /api/storage/buckets | Rename a bucket |
| DELETE | /api/storage/buckets | Delete a bucket (must be empty) |
{
"projectId": "YOUR_PROJECT_ID",
"name": "profile-photos",
"isPublic": false
}
// Name rules: lowercase alphanumeric, hyphens, underscores, 1–63 chars| Method | Endpoint | Action |
|---|---|---|
| POST | /api/storage/upload | Upload file (multipart/form-data) |
| GET | /api/storage/files?bucketId=…&projectId=… | List files in a bucket |
| GET | /api/storage/url?s3Key=…&projectId=… | Get 15-min pre-signed download URL |
| DELETE | /api/storage/files | Delete a file (S3 + database) |
Send multipart/form-data — required fields: file, bucketId, projectId. bucketId accepts the bucket UUID or name.
curl -X POST "https://www.fluxbasedb.me/api/storage/upload" \
-H "Authorization: Bearer $FLUXBASE_API_KEY" \
-F "file=@avatar.jpg" \
-F "bucketId=profile-photos" \
-F "projectId=YOUR_PROJECT_ID"{
"success": true,
"file": {
"id": "uuid-here",
"name": "avatar.jpg",
"s3_key": "YOUR_PROJECT_ID/bucket-uuid/avatar.jpg",
"size": 204800,
}Manage project collaborators and send role-based invitations programmatically. All team endpoints require admin-level privileges.
{
"members": [
{ "userId": "usr_abc", "email": "alice@acme.com", "displayName": "Alice", "role": "admin", "joinedAt": "2026-01-10T09:00:00Z" }
],
"invites": [
{ "id": "inv_xyz", "email": "bob@acme.com", "role": "developer", "invitedAt": "2026-04-14T11:00:00Z" }
]
}{
"projectId": "YOUR_PROJECT_ID",
"email": "newmember@company.com",
"role": "developer"
}| Role | Permissions |
|---|---|
| admin | Full access — manage members, settings, billing, and data. |
| developer | Read/write data, manage schemas. Cannot manage billing or members. |
| viewer | Read-only access to data and the dashboard. |
{
"inviteId": "inv_xyz",
"status": "accepted"
}[ DEVELOPER ] [ TEAM ] without affecting their personal account billing. Meanwhile, all database limits for that project (tables, rows, instance sizes, webhooks, and scrapers) evaluate against the Project Owner's plan tier—enabling team members to work seamlessly in high-tier enterprise projects without hitting personal plan limits.Webhooks are outbound HTTP POST requests sent from Fluxbase to your server when data events occur. Ideal for serverless functions (Vercel, AWS Lambda, Cloudflare Workers).
Register a Secret in your webhook config. Fluxbase signs every delivery with an X-Fluxbase-Signature HMAC-SHA256 header for you to verify.
{
"event_type": "row.inserted",
"project_id": "YOUR_PROJECT_ID",
"table_id": "orders",
"timestamp": "2026-04-14T12:00:00.000Z",
"data": {
"new": { "id": 123, "customer_id": 7, "amount": 59.99, "status": "pending" },
"old": null
}
}import crypto from 'crypto';
export async function POST(req) {
const rawBody = await req.text();
const sig = req.headers.get('x-fluxbase-signature') ?? '';
const secret = process.env.FLUXBASE_WEBHOOK_SECRET;
const expected = crypto
.createHmac('sha256', secret)
.update(rawBody)
.digest('hex');
if (sig !== `sha256=${expected}`) {
return new Response('Unauthorized', { status: 401 });
}
const event = JSON.parse(rawBody);
console.log('[Webhook]', event.event_type, event.data.new);
// Your business logic here...
return new Response('OK', { status: 200 });
}Fluxbase uses standard HTTP status codes alongside machine-readable error codes in the response body.
| HTTP Status | Error Code | Meaning & Fix |
|---|---|---|
| 401 | AUTH_REQUIRED | API key missing or malformed. Include Authorization: Bearer <key>. |
| 401 | TOKEN_EXPIRED | Session token has expired. Re-authenticate to get a new token. |
| 403 | SCOPE_MISMATCH | API key does not have access to this project or resource. |
| 403 | PROJECT_SUSPENDED | Project is suspended due to plan limits or billing. Upgrade your plan. |
| 403 | INSUFFICIENT_PERMISSIONS | Only admins can perform this action (e.g., inviting members). |
| 404 | PROJECT_NOT_FOUND | No project found for the given projectId. Check your ID. |
| 404 | USER_NOT_FOUND | Invitee email does not match any registered Fluxbase account. |
| 429 | RATE_LIMIT | 50 requests per 10 seconds exceeded. Implement exponential backoff. |
| 500 | INTERNAL_ERROR | Unexpected server error. These are logged and auto-reported. |
| 503 | DATABASE_CONNECTION_ERROR | Transient database connectivity issue. Retry after a few seconds. |
| 200 | SQL_EXEC_ERROR | SQL syntax or logic error. Check the error.details field for the Postgres error. |
Your logged-in user ID is injected via SET LOCAL fluxbase.auth_uid before each query.
PostgreSQL runs your USING expression (e.g. user_id = auth.uid()) before returning any row.
Rows that fail the policy are silently excluded — no errors, just scoped results.
Navigate to Database → Row Level Security in your project sidebar. All tables are listed.
Choose a table, select command scope (ALL / SELECT / INSERT / UPDATE / DELETE), then write your USING expression.
Toggle the switch. Fluxbase immediately runs ALTER TABLE … ENABLE ROW LEVEL SECURITY and CREATE POLICY.
Run SELECT * FROM your_table — you'll only see rows that pass the policy for the authenticated user.
Classic pattern for posts, orders, and profiles.
user_id = auth.uid()All members of an organization share visibility. Set auth.uid() to the org ID at the API level.
org_id = auth.uid()Create two policies on the same table with different command scopes.
trueauthor_id = auth.uid()Useful for internal audit tables that no API caller should read.
false| Problem | Cause | Fix |
|---|---|---|
| Query returns 0 rows | Policy never matches | Temporarily set USING to true to confirm RLS is the cause. |
| Policy toggle fails | Column in expression missing | Ensure user_id (or the referenced column) exists in the table. |
| User can't see own rows | Type mismatch (INT vs TEXT) | Cast explicitly: user_id::text = auth.uid() |
| Admin locked out | FORCE ROW LEVEL SECURITY active | Run ALTER TABLE … NO FORCE ROW LEVEL SECURITY in the SQL Editor. |
Our team is available for architecture reviews and custom integration support.