Scribase

Connect Remote server

claude mcp add --transport http scribase https://api.scribase.com/mcp

{
  "mcpServers": {
    "scribase": {
      "url": "https://api.scribase.com/mcp"
    }
  }
}

{
  "servers": {
    "scribase": {
      "type": "http",
      "url": "https://api.scribase.com/mcp"
    }
  }
}

Settings > Connectors > Add custom connector
URL: https://api.scribase.com/mcp

Tools 80 found in our last check

• projects.list

  List your projects with their branches and status. Start here to find project ids. Scope: projects:read.

• projects.create

  Create a new backend (Postgres, Auth, Storage, Realtime, Functions) and wait until it is live. Everything is optional: the name, region and database engine are picked for you. Returns the project URL and publishable key, ready for createClient(). If the project adds to this mont…

• keys.get

  The project URL and publishable (anon) key for supabase-js, as .env lines. The secret (server-only) key is included only with include_secret: true and the keys:secret scope; it bypasses row level security and must never reach client code. Scope: keys:read.

• projects.start

  Bootstrap a real backend (Postgres, Auth, Storage, Realtime, Functions) with no account and no bearer token: call this before `initialize` ever sees an Authorization header. Solves its own proof-of-work, creates a temporary project (expires in about 72h unless claimed), and retu…

• sql.execute

  Run SQL on a branch as the project's database role (never a superuser). Read-only by default. For writes pass read_only: false (database:write). DROP, TRUNCATE, ALTER ... DROP and DELETE/UPDATE without WHERE are destructive: they need confirm: true plus the destructive scope, an…

• migrations.list

  Migrations already applied to a branch, oldest first. Scope: database:read.

• migrations.apply

  Record and apply one migration (name + SQL) in a single transaction, then reload the REST API's schema cache. It is linted first: a table without row level security is blocked. dry_run: true only lints. Destructive SQL needs confirm: true and the destructive scope (production:de…

• tables.list

  Tables on a branch with row counts, and whether row level security is on. Scope: database:read.

• tables.describe

  Columns, primary key, foreign keys, indexes, row level security and policies of one table. Scope: database:read.

• types.generate

  The supabase-js `Database` TypeScript type for a branch's schema. Save it as database.types.ts and use createClient<Database>(url, key). Scope: database:read.

• functions.list

  Edge functions deployed to a branch. Scope: functions:read.

• functions.deploy

  Create or replace an edge function (Deno, TypeScript). Pass `source` for a single file, or `files` (path -> source) with an `entrypoint`. It is served at <project URL>/functions/v1/<name>. Scope: functions:write.

• functions.logs

  Recent log lines of one edge function. Scope: logs:read.

• storage.buckets.list

  Storage buckets on a branch. Scope: storage:read.

• storage.buckets.create

  Create a storage bucket. Private by default; public: true makes objects readable by URL. Scope: storage:write.

• auth.config.get

  Auth settings (site URL, redirect allow list, JWT expiry, sign-up rules) and providers. Scope: auth:read.

• auth.config.set

  Change auth settings (`settings`, a partial object: site_url, uri_allow_list, jwt_exp, ...) and/or one provider (`provider` such as google, github, apple, email with `provider_config` such as {enabled, client_id, secret}). Applied to the running auth service. Needs an owner or a…

• capabilities.status

  Which one-command add-ons (email, errors, ...) a branch has and whether each is live, with a proof record {kind, id, at}. Pass `slot` for one. Never returns a credential. Scope: projects:read.

• capabilities.add

  Turn on a capability slot such as email for a branch. When it needs the person's own credential, the answer holds a connect_url to hand to them; never ask for a key in chat. Then poll capabilities.status until live is true. Scope: projects:write.

• extensions.list

  Postgres extensions this branch can enable (vector, pgmq, pg_jsonschema, index_advisor, ...) and which are on. Pass `category` to filter. Scope: database:read.

• extensions.enable

  Enable an allowlisted Postgres extension on a branch. With name vector and search_table: true it also creates a semantic search table and match function. Scope: database:write.

• schedule.list

  The branch's scheduled jobs (pg_cron): name, schedule, target, whether active, and the last run. Scope: database:read.

• schedule.create

  Run SQL or a function on a timer. `schedule` is five cron fields in UTC ("0 3 * * *") or "N seconds" (1 to 59). Give exactly one of `sql` or `function`; `payload` goes with `function`. Jobs run while the project sleeps and every run is logged. Scope: database:write.

• schedule.update

  Change a job: `active` false pauses it, true resumes it; `schedule` sets a new timer. Scope: database:write.

• schedule.delete

  Delete a job and stop its runs. Show the user which job goes, then call with confirm: true. Scope: database:write.

• schedule.run

  Run a job once now, outside its timer. The run is logged like any other. Scope: database:write.

• schedule.runs

  Recent runs of one job: when, how long, succeeded or failed, and the message. Scope: database:read.

• errors.list

  Errors from the app on this branch, grouped into issues, with usage and the DSN to put in the Sentry SDK. Turn the slot on with capabilities.add slot errors. Scope: logs:read.

• errors.get

  One issue with its latest event and stack trace. `issue_id` is the numeric id from errors.list. Scope: logs:read.

• push.status

  Whether push is set up on this branch and how many devices and users it reaches. Set it up with capabilities.add slot push. Scope: logs:read.

• push.send_test

  Sends one push to every device of one app user (by `user_id` or `email`) through the Expo push service. Answers devices, sent, failed and pruned (dead tokens removed). Scope: functions:write.

• ota.status

  Whether over-the-air updates are set up on this branch, the update URL the app reads, and the newest release per platform and channel. Set it up with capabilities.add slot ota (or `scribase ota setup`); publish with the unmodified hot-updater CLI (`npx hot-updater deploy -p ios`…

• ota.releases

  Published releases, newest first: id, platform, channel, target app version, whether it is on, the share of devices that get it, and its message. Scope: functions:read.

• ota.rollback

  Turns off the newest release that is on for a platform and channel; devices on it go back to the release before it (or the bundle built into the app) on their next launch. Needs "confirm": true after the user agrees. Scope: functions:write.

• links.list

  The branch's link host, what still stops links from opening the app, the short links with their in-app paths and clicks, and last week's clicks by platform. Scope: logs:read.

• links.create

  A short link that opens the app on `path` (and after install, on first launch); a computer goes to the web fallback with the same path. Answers the code and URL. Scope: functions:write.

• logs.get

  Recent log lines for a branch, newest first: auth, rest, storage, realtime, functions or gateway. Scope: logs:read.

• branches.list

  Branches of a project with kind, status, parent and expiry. Production is protected. Scope: branches:read.

• branches.create

  Fork a branch from production (or `from`) for one task, agent or pull request: a copy-on-write database with its own URL and keys. Expires after ttl_hours. Returns its URL and publishable key once live. Scope: branches:write.

• branches.merge

  Merge a branch's schema changes into its parent (default production). Without apply it is a dry run that shows the plan and conflicts; apply: true with confirm: true applies it. Scope: branches:write.

• branches.reset

  Throw away a branch's changes and take its parent's current data, in place: the URL and keys stay. Destructive: needs confirm: true and the destructive scope. Refused on production. Scope: branches:write.

• branches.restore

  Rewind a branch in place to a point in time; the URL and keys stay and the state before is kept. Destructive: needs confirm: true and the destructive scope; production additionally needs production:destructive. Scope: branches:write.

• branches.masking.set

  What a sanitized branch (branches.create data: "sanitized") masks. Every sanitized branch already hashes auth emails and phone numbers and removes sign-in metadata, password hashes and IP addresses; add the project's own columns as [schema.]table.column:transform (hash, null, ma…

• branches.delete

  Delete a branch and its database. Destructive: needs confirm: true and the destructive scope; a production branch additionally needs production:destructive. Scope: branches:write.

• draft_x_launch_post

  Turn a launch into an X (Twitter) post or a numbered thread. Returns posts, each with text, weighted_length (twitter-text parseTweet: 280 max, URLs count as 23, emoji and CJK count extra) and intent_url (https://x.com/intent/post) that opens the composer prefilled. It does not c…

• docs.search

  Search Scribase docs: how to connect an app, row level security, branching, migrations, functions, storage, auth, tokens. Returns short answers with links.

• deploy.run

  Returns the one command that deploys this project's app to the user's own Cloudflare account (run it in the app's folder: it links the deploy slot on first use), with the slot state and the latest deploys. Nothing is changed by this call. Scope: projects:read.

• analytics.summary

  Visitors and events of the app on this branch over 7 days, the visit to sign-up to first action funnel, the plan cap note, and page speed with a marker per deploy when that is switched on. Scope: projects:read.

• flags.list

  The flags of this branch's environment: key, on or off, value and description. Scope: projects:read.

• flags.set

  Creates or changes one flag of this branch's environment; apps read the change within a minute with no redeploy. Reversible: set it back the same way. Scope: projects:write.

• uptime.status

  The project's uptime checks with their current state (up, down or waiting), last result and public status page. Scope: projects:read.

• ai.keys

  The AI gateway for this branch: its keys' daily and monthly caps and usage, and which providers are connected. Never returns a key. Scope: keys:read.

• billing.products

  The products and prices on the user's own connected payment account for this branch, and whether a processor is connected. The buyer pays the user's account directly. Scope: projects:read.

• addon.status

  Whether the organization's Portfolio add-on is active, since when, when it renews, and which slots it unlocks. Scope: projects:read.

• schema.propose

  Compile a schema and return the SQL it would apply. Read-only; touches no database. Row level security is always enabled and forced.

• policy.simulate

  Apply the schema to a scratch branch and prove tenant isolation: two users, an anonymous client, forged ownership, ownership transfer. Returns a token only when every check passes.

• policy.test

  Run the Aegis mutation harness: prove isolation on a fresh branch, then break each guarantee on purpose (FORCE RLS removed, a policy made USING (true), a WITH CHECK dropped) on throwaway branches and require every break to be caught. Returns an apply token only when the baseline…

• schema.apply

  Apply a schema that policy.test (or policy.simulate) already proved safe. Takes the token it issued, not SQL — there is no way to apply a policy that has not been proven.

• sql.explain

  Explain a single SELECT. Read-only; writes are refused.

• org.get

  Read an organization. GET /v1/organizations/{id}.

• org.put

  Create or update an organization. PUT /v1/organizations/{id}.

• member.put

  Set a member's role. PUT /v1/organizations/{id}/memberships. Role is one of owner, admin, developer, viewer.

• project.get

  Read a project. GET /v1/organizations/{id}/projects/{project}. Also starts the project's production environment in the background, so the next query does not wait for a cold start.

• project.put

  Create or update a project. PUT /v1/organizations/{id}/projects/{project}.

• environment.list

  List environments in an organization, optionally filtered to a project. GET /v1/environments.

• environment.get

  Read one environment, including its phase and last error. GET /v1/organizations/{id}/projects/{project}/environments/{env}.

• environment.create

  Provision an environment. POST /v1/environments. kind is preview, staging, or production; data_mode is schema_only, sanitized, or snapshot.

• environment.delete

  Delete an environment. DELETE /v1/organizations/{id}/projects/{project}/environments/{env}.

• environment.suspend

  Suspend an environment. POST .../environments/{env}/suspend.

• environment.resume

  Resume a suspended environment. POST .../environments/{env}/resume.

• operation.get

  Poll an asynchronous operation. GET /v1/operations/{id}. Requires the owning organization so the read stays inside its tenant.

• audit.list

  List audit events for an organization. GET /v1/organizations/{id}/audit-events. Pass after and limit together to page.

• import.status

  Follow a background import. GET /v1/imports/{id}. Returns status (running, succeeded, failed, interrupted), the current phase, counts moved so far, findings, errors, whether it is resumable, and the full report once it has finished.

• import.supabase

  Import a live Supabase project into an environment. POST /v1/imports. With dry_run true it reports what would move and changes nothing; without it the import starts in the background (so requires confirm) and returns an import_id to follow with import.status.

• import.postgres

  Import a plain Postgres database (Neon, Render, RDS, self-hosted) into an environment. POST /v1/imports. Only a connection string is needed: unlike Supabase, there is no platform API alongside the database, so no service key or storage is asked for. With dry_run true it reports…

• migrate.run

  Plan, lint, and optionally apply migrations. POST .../environments/{env}/migrations. migrations is a JSON array of {version,name,up,down?}. Without apply it only plans and lints; with apply true it applies and so requires confirm.

• export.run

  Assemble a runnable, signed export bundle. POST .../environments/{env}/exports. format is compose (default) or kustomize.

• org.list

  List all organizations the caller belongs to. GET /v1/organizations.

• project.list

  List all projects in an organization. GET /v1/organizations/{id}/projects.

• branch.list

  List recorded branches for a project. GET /v1/organizations/{id}/projects/{project}/branches.

Details

More databases servers See all

• VibeScale

  Pre-launch checks for AI-built apps: leaked keys, Supabase RLS gaps, browser-exposed env vars.

• Imf Mcp Server

  Query IMF SDMX 3.0 macroeconomic dataflows — WEO, BOP, CPI, exchange rates, 190 countries.

• Apex DB

  Vehicle specifications, emissions, and powertrain data with source provenance.

• TrialBase DB

  Clinical trials across multiple registries with identifiers and source links.

• PatchLabs

  Security checks for AI-built apps (Lovable, Supabase, Bolt): RLS, headers, monitoring, fixes.

• Tidy Byte Tools API

  Remote MCP for JSON repair, hashing, formatting, IDs, dates, units, and other small tools.