A Turso MCP for the control plane: databases, groups, tokens and usage
Connect one Turso platform token and your organization slug, and 49 nodes land on the canvas: create databases into groups, branch from a point in time, mint and revoke SQL tokens, add and remove replica locations, read usage and top queries, walk the audit log, and manage members and invites. Everything Turso's Platform API documents, running on a schedule or from an AI assistant.
What the Turso MCP connector does
The Turso connector for Mattering Automations is 49 nodes covering all 49 operations in Turso's published Platform API document: databases and their configuration, instances, usage and stats, groups and the locations they replicate to, organization settings, plans, subscriptions, invoices and usage, members, invites, and both families of token minting. It is the control plane for edge SQLite, on your canvas and available to any AI assistant you connect.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can create a database into a group with Turso: Create Database, mint a scoped token for it with Turso: Create Database Token, and hand the hostname and token to the tenant, all as a single workflow that also files the result in a Mattering database.
One boundary is deliberate and stated up front, because it is the first thing anyone asks. This connector talks to the Platform API only and never touches a database's own hostname, so there is no node here that runs SQL against your data. That is not an oversight, it is Turso's own architecture: the vendor documents platform tokens as control-plane credentials that are independent from the SQL-engine tokens an application uses to query a database, and states that the two systems share neither key material nor vocabulary. A SQL node would therefore need a live database token supplied as node configuration, which means a working production database credential sitting in workflow inputs and execution records. The connector mints those tokens through Turso: Create Database Token and Turso: Create Group Token, and it never consumes them.
Turso publishes its own MCP server, so know what it is before you choose. Turso runs a hosted Model Context Protocol server for Turso Cloud, authenticated with OAuth so an agent gets a scoped token through the browser rather than a pasted key, and it covers three things: database management including branching, SQL execution split into separate tools for reads, writes, deletes and schema changes, and per-database insight such as top queries. If what you want is an agent that queries and edits your data conversationally, Turso's own server does that and this connector deliberately does not. What this connector adds is the rest of the control plane and a different place to run it: groups and replica locations, members, invites and roles, audit logs, plans, subscriptions and invoices, and both token families, as steps that run on a schedule or a trigger with nobody present, chain with every other connector in one workflow, hold the credential in a shared workspace store rather than in one person's client, and carry destructive flags you can gate on.
The safety modeling is stated rather than implied. Of the 49 nodes, 25 read and 24 act, and seven are flagged destructive: Turso: Delete Database, Turso: Delete Group, Turso: Invalidate Database Tokens, Turso: Invalidate Group Tokens, Turso: Revoke API Token, Turso: Revoke Organization API Token and Turso: Transfer Group. Three more are classed destructive for testing without the flag, because they change a lot at once while losing nothing irrecoverable: Turso: Remove Location From Group, Turso: Remove Member and Turso: Update Databases In Group. The four token nodes are worth separating from the two delete nodes in your head: no data is lost when a signing key rotates, but every client holding an old token stops authenticating the instant it returns, with no grace period and no way back to the old value.
One connection, three surfaces
- Visual automations. Drag Turso nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Turso node, ready to drop on the canvas
49 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 25
Turso: Get Current Subscription
Read the organization's current subscription: the plan name, whether it is billed monthly or yearly, and whether overages are enabled. Pair with Turso: List Plans to turn the plan name into its quota numbers.
Turso: Get Current User
Read the account the platform token belongs to: username, display name, primary email, avatar URL, current plan, whether multi-factor authentication is enabled and whether there are pending organization invites waiting.
Turso: Get Database
Read one database: its UUID, the hostname clients connect to, its group, primary and replica regions, delete-protection flag and blocked read/write status. Turso documents no operation-polling endpoint, so read a newly-created database back with this node rather than assuming it is ready to accept connections.
Turso: Get Database Configuration
Read a database's settings: size limit, whether other databases may ATTACH to it, whether reads or writes are blocked, whether delete protection is on, and any IP or AWS VPC allow lists. The response is a FLAT object with no wrapper key, so paths read data.size_limit rather than data.configuration.size_limit.
Turso: Get Database Instance
Read one instance of a database by its location code: UUID, primary or replica, region and hostname.
Turso: Get Database Stats
Read the top queries running against a database, each with the rows it read and the rows it wrote. This is the node that finds the expensive query behind a usage spike, since Turso bills on rows read and written. The query text comes back verbatim, so treat the output as potentially revealing about schema and application behaviour.
Turso: Get Database Usage
Read one database's usage over a time period: rows read, rows written, storage bytes and bytes synced, both as a total and broken down per instance. Both bounds default to the current calendar month. The response carries NO per-day rows: it is a single aggregate for whatever window you ask for, so building a daily series means one request per day. storage_bytes is a size at a point in time and must never be added across windows.
Turso: Get Group
Read one group: name, UUID, primary location, the full list of locations it replicates to, delete-protection flag and the libSQL version its databases run. Also the source for the location picker on Turso: Remove Location From Group.
Turso: Get Group Configuration
Read a group's configuration. The only documented setting is delete_protection, which when enabled prevents the group and all its databases from being deleted. The response is a FLAT object with no wrapper key, so the path is data.delete_protection.
Turso: Get Member
Read one organization member by username: their email and their role. A username that is not a member returns HTTP 404 with error could not find member.
Turso: Get Organization
Read the organization the credential is scoped to: name, slug, whether it is a personal or team account, its plan and billing timeline, whether overages are enabled, whether MFA is required, and whether reads or writes are currently blocked account-wide. Blocked reads or writes here explain an otherwise baffling wave of client failures. A slug that does not exist returns HTTP 404, which makes this the cheapest way to confirm the credential's organization_slug is right.
Turso: Get Organization Usage
Read the organization's usage for the CURRENT BILLING CYCLE: rows read and written, storage bytes, bytes synced, plus a per-database breakdown. Takes no date range at all, unlike the per-database usage node, so it always describes the cycle in progress and cannot be windowed or back-filled. Compare against Turso: List Plans to see how close the account is to a quota.
Turso: List API Tokens
List the platform API tokens belonging to the authenticated USER, with each token's name, id, the organization it is restricted to, the group it is pinned to if it is group-scoped, its expanded scopes and its creation date. Token material is never returned by any read. This lists the caller's own tokens across organizations; for tokens scoped to one organization including other people's, use Turso: List Organization API Tokens.
Turso: List Audit Logs
Read the organization's audit trail newest first: who did what, when, and from the CLI or the web. Codes include db-create, db-delete, db-protect, db-token-create, group-token-create, user-token-create, instance-create, instance-delete, group-create, group-delete, group-unarchive, org-member-add, org-member-rm, org-plan-update and org-set-overages. Paginated with page and page_size; the response carries page, page_size, total_pages and total_rows under data.pagination. Note this is PAGE-NUMBER pagination rather than a cursor, so rows can shift between pages while new events arrive.
Turso: List Database Instances
List the physical copies of a database: one primary plus a replica in each additional location the group covers. Each instance carries its UUID, its location code as the name, whether it is primary or replica, and its own hostname. Instances follow the GROUP's locations; you change them with Turso: Add Location To Group rather than per database.
Turso: List Databases
List every database in the organization, each with its name, UUID, connection hostname, group, primary region, replica regions, delete-protection flag and blocked read/write status. A branched database also carries a parent object with the source database id and the time it was branched. This is the lister behind every database picker in this connector. Field names follow the vendor's capitalization: data.databases[].Name.
Turso: List Groups
List the organization's groups. A group is the unit that owns locations: every database inside it is replicated to the same set of regions and shares one signing key. Each group returns its name, UUID, primary location and delete-protection flag. The version and locations fields are marked deprecated by Turso but are still returned.
Turso: List Invites
List the organization's PENDING invites with the invited email, the role they were offered and when the invite was created. Accepted invites drop off this list and appear under Turso: List Members instead, so this is the node for chasing invitations nobody has accepted. Note the v2 path.
Turso: List Invoices
List the organization's invoices with amount due, due date, when each was paid, when payment last failed, and a downloadable PDF link. The payment_failed_at field is the one worth alerting on: a failed payment is what precedes an account being blocked.
Turso: List Locations
List every location a group or database can be created or replicated in. The response is a MAP keyed by location code, not a list, so one location reads as data.locations.aws-us-east-1 and there is no data.locations[].code path. Use this to find the code for Turso: Create Group or Turso: Add Location To Group.
Turso: List Members
List the organization's members with their username, email and role. Roles are owner, admin, member and viewer; owner is reported here but cannot be assigned through the API. This is the lister behind every member picker in this connector.
Turso: List Organization API Tokens
List the platform API tokens scoped to this organization, both organization-scoped and group-scoped, each with the member who minted it under owner. What you see depends on your role: admins and owners see every token scoped to the organization, while members and viewers see only the ones they minted themselves. Deprecated unrestricted tokens do not appear here at all; find those with Turso: List API Tokens. This is the audit node for finding forgotten credentials.
Turso: List Organizations
List the organizations this token can act on, each with its SLUG, type (personal or team), plan, overage setting and whether reads or writes are currently blocked. Run this first: the slug it returns is the value the Turso credential needs, and almost every other node in this connector is scoped by it. Note this response is a TOP-LEVEL ARRAY, so paths read data[].slug rather than data.organizations[].slug. Every user has a personal organization whose slug is their username.
Turso: List Plans
List the plans available to this organization with their prices and QUOTAS: rows read, rows written, database count, location count, storage bytes, group count and bytes synced. This is the only non-guessing way to read what Turso allows an account, and it is the node to reach for when a create call starts returning HTTP 402. The numbers come from the live API rather than from a pricing page, so they reflect what the account is actually entitled to.
Turso: Validate API Token
Check that the stored platform API token is still valid and read when it expires. Returns data.exp as unix epoch seconds or -1 when the token never expires. This is the cheapest possible credential check: no organization in the path and no parameters and no secret material echoed back. An invalid or expired token answers HTTP 401.
Action nodes 24
Turso: Add Location To Group
Replicate a group into an additional region. Every database in the group gains a read replica there, which is how you put data near users. An unknown code returns HTTP 400 with error invalid location, and exceeding the plan's location quota surfaces as HTTP 402. The response returns the group's new full location list.
Turso: Add Member
Add an EXISTING Turso user to the organization by username, with immediate effect and no invitation step. Use Turso: Create Invite instead when the person does not already have a Turso account or when you only have their email. An unknown username returns HTTP 404 and someone already in the organization returns HTTP 409.
Turso: Create API Token
Mint a new PLATFORM API token, the credential that calls this API. THE RESPONSE CONTAINS THE TOKEN AT data.token AND TURSO NEVER REVEALS IT AGAIN, so whatever consumes this node is the only thing that will ever see it, and it will be stored in this run's execution record. Three levels of restriction, narrowest last: leave organization blank for an unrestricted token, which Turso has DEPRECATED and will remove; set organization for an organization-scoped token; set organization plus group plus scopes for a group-scoped token, which the caller must be an admin or owner to mint. Prefer the narrowest that works.
Turso: Create Database
Create a database inside an EXISTING group. The group must already exist: creating a database into a group that does not returns HTTP 400 with error group not found, and a name already in use returns HTTP 409. The response carries only the new name, DbId and Hostname, so read it back with Turso: Get Database for the full record. The seed object also drives two other workflows: copying an existing database (optionally at a past timestamp, which is how point-in-time recovery works) and preparing a database to receive an uploaded SQLite file. Plan quotas apply and a refusal surfaces as HTTP 402.
Turso: Create Database Token
Mint a SQL token for one database. This is the second half of the database-per-user pattern: create the database, mint its token, hand the hostname and token to the tenant. THE RESPONSE CONTAINS A LIVE CREDENTIAL at data.jwt, which will be stored in this run's execution record, so treat the run output accordingly. This token is a SQL-engine credential and is a different thing from the platform API token this connector authenticates with; it cannot call the Platform API and the platform token cannot query a database. Set authorization to read-only for anything that should not write. Existing tokens are unaffected by minting a new one; only Turso: Invalidate Database Tokens revokes them.
Turso: Create Group
Create a group in a primary location. Databases are created into groups, so this is the first call in a fresh organization. A name already in use returns HTTP 409, and a group count over the plan quota surfaces as HTTP 402. Note that a group-scoped API token cannot call this at any scope: group create is gated to organization-level credentials.
Turso: Create Group Token
Mint one SQL token that works against EVERY database in the group, including databases created later. That is its point and also its risk: it is the right credential for an application that owns a whole group and the wrong one for a single tenant, who should get a per-database token from Turso: Create Database Token instead. THE RESPONSE CONTAINS A LIVE CREDENTIAL at data.jwt and will be stored in this run's execution record. Like the database token this is a SQL-engine credential and cannot call the Platform API.
Turso: Create Invite
Invite someone to the organization. Supply EXACTLY ONE of email or username: an email works even when the person has no Turso account yet, in which case they get a signup link, while a username targets an existing user. An existing pending invite for the same email is REPLACED rather than duplicated, which makes this safely repeatable. Membership only takes effect when they accept; use Turso: Add Member for an immediate add.
Turso: Delete Database
DESTRUCTIVE AND IRREVERSIBLE. Delete a database and everything stored in it. Be precise about what point-in-time recovery does and does not cover here: Turso PITR restores by creating a NEW database FROM AN EXISTING one at a past timestamp, so it protects against mistakes made INSIDE a database that still exists, such as a dropped table. Nothing in the Platform API reference or the PITR documentation describes restoring a database once it has been deleted. What IS recoverable is whatever you copied out beforehand with Turso: Create Database using a seed. Every SQL token issued for this database also stops being useful. The call is refused while delete_protection is enabled on the database; turn it off with Turso: Update Database Configuration first. The response returns just the deleted name as a STRING at data.database.
Turso: Delete Group
DESTRUCTIVE AND IRREVERSIBLE. Delete a group. This is the widest blast radius in the connector: the group's own configuration documents delete protection as preventing the group AND ALL ITS DATABASES from being deleted, so every database inside goes with it, and Turso's authentication documentation states that deleting a group cascades a revoke to every API token scoped to it. What is NOT recoverable: the databases and their data, since point-in-time recovery works by copying from a database that still exists, and the revoked tokens. What IS recoverable: nothing, unless the databases were copied out beforehand. Refused while the group's delete_protection is enabled. Group delete is also unreachable from a group-scoped token at any scope.
Turso: Delete Invite
Withdraw a pending invite by the email it was sent to. Fully reversible: re-inviting the same address restores the same offer, and nothing about the organization changes. An email with no pending invite returns HTTP 404 with error invite not found. The email is a PATH segment and is URL-encoded for you.
Turso: Invalidate Database Tokens
DESTRUCTIVE AND IRREVERSIBLE. Rotate the database's signing key, which invalidates EVERY SQL token ever issued for this database, at once and with no grace period. No data is lost and the database keeps running, but every application, service and integration holding an old token starts failing authentication immediately and stays broken until it is given a freshly minted token. Old tokens cannot be brought back. Use this when a token has leaked; do not use it as routine hygiene unless every consumer can be re-issued in the same operation. Answers with an empty body.
Turso: Invalidate Group Tokens
DESTRUCTIVE AND IRREVERSIBLE. Rotate the GROUP's signing key, invalidating every SQL token ever issued against ANY database in the group, group tokens and per-database tokens alike. This is the widest credential revocation in the connector: in a database-per-tenant setup it logs out every tenant at once. No data is lost and the databases keep running, but nothing can connect until every consumer has been re-issued a token, and the old ones cannot be brought back. Answers with an empty body.
Turso: Remove Location From Group
Stop replicating a group into a region. The replica copies in that location are dropped, so clients there lose their nearby read path and fall back to a further one. This is NOT irreversible and it does not lose data: the primary still holds everything and adding the location back re-replicates it, at the cost of a resync. Turso does not document what happens if you name the group's PRIMARY location, so do not aim this at data.group.primary.
Turso: Remove Member
Remove a member from the organization. Their access ends immediately. NOT irreversible and no data is lost: the organization's databases and groups are untouched and the same person can be added back with Turso: Add Member, though they lose the role they had unless you set it again. Classed Destructive so the endpoint test matrix does not quietly eject a real colleague from a live organization.
Turso: Revoke API Token
DESTRUCTIVE AND IRREVERSIBLE. Revoke one of your own platform API tokens by NAME. It stops working immediately and anything using it, including possibly this connector's own credential, starts returning HTTP 401. The token cannot be restored: Turso never revealed the material a second time, so recovery means minting a new token and updating every consumer. No databases or data are affected.
Turso: Revoke Organization API Token
DESTRUCTIVE AND IRREVERSIBLE. Revoke a token scoped to this organization, addressed by its ID rather than its name because names are unique per user and an admin revoking a member's token cannot disambiguate by name alone. It stops working immediately and whatever was using it starts returning HTTP 401; it cannot be restored, only replaced. Admins and owners can revoke any token scoped to the organization; members and viewers can revoke only their own. No databases or data are affected.
Turso: Transfer Group
Move a group and every database in it to another organization you own or belong to. Be precise about what is and is not undoable: the MOVE itself can be reversed by transferring back if you hold rights in both organizations, but Turso's authentication documentation states that transferring a group cascades a revoke to every API token scoped to it, and revoked tokens never come back. After a transfer this connector's credential no longer reaches the group at all, because the credential carries one organization slug; you need a credential for the destination organization. Group transfer is also unreachable from a group-scoped token at any scope. Usage and billing move with the group.
Turso: Unarchive Group
Wake a group that Turso archived for inactivity. Archived groups stop serving their databases until this is called, so a scheduled workflow that hits an archived group can call this first and then retry. No data is lost by archiving; the group returns with everything in it.
Turso: Update Database Configuration
Change a database's settings in place. Every field is optional and only the ones you fill are sent. Two of them take a live database offline the moment they are set: block_reads and block_writes make the database reject client queries until they are turned off again, which is useful as a deliberate freeze and painful by accident. delete_protection is the safety catch that makes Turso: Delete Database refuse. Setting allowed_ips restricts which addresses can connect at all.
Turso: Update Databases In Group
Upgrade every database in the group to the latest libSQL server version. Marked destructive for TESTING purposes rather than for data loss: no data is deleted, but the version change applies to every database in the group at once, Turso documents no downgrade endpoint, and there is no dry run. Treat it as a planned maintenance action on a group you own, not something to run against a production group to see what happens. Answers with an empty body.
Turso: Update Group Configuration
Turn a group's delete protection on or off. Switching it on is the cheapest guard available against Turso: Delete Group, which would otherwise take every database in the group with it. Switching it off is the deliberate step before a planned teardown.
Turso: Update Member Role
Change an existing member's role. Only admins and owners can do this; anyone else gets HTTP 403 with error updating member roles is only allowed for admin or owner. Reversible by setting the previous role back, so read the member first if you intend to restore it. Demoting the only admin leaves nobody able to promote anyone.
Turso: Update Organization
Change organization-wide settings. overages decides whether usage beyond the plan's quota is billed rather than refused, so turning it OFF converts a future overage into HTTP 402 failures on create and write paths, and turning it ON accepts the charge. require_mfa forces every member to have multi-factor authentication; the caller must already have MFA on their own account before enabling it, and members without MFA will be locked out until they set it up. Both are reversible by setting them back.
Connecting Turso takes one credential
Turso authenticates the Platform API with a bearer token minted through the Turso CLI, and this connector's credential carries a second, non-secret field alongside it: the organization slug. That is because 44 of the 49 operations put the slug in the URL path, and because Turso scopes its own tokens to one organization by design: the vendor documents unrestricted cross-organization tokens as deprecated and due for removal, tells you to scope new tokens with the organization flag, and models its own client on an organization plus a token. So one connection addresses one Turso organization, and someone who genuinely works across two creates two connections. Mint the token with the CLI command for creating a platform API token, scoped to the organization; read the slug from the CLI's organization list, or run Turso: List Organizations after connecting, where it comes back at data[].slug. For a personal account the slug is your username. Know which restriction level your token carries, because it gates nodes rather than plans: an organization-scoped token is the recommended shape and reaches everything here, while a group-scoped token cannot create, delete or transfer a group at any scope and will answer those three nodes with 403 no matter what. Capacity is gated by plan and surfaces as HTTP 402 rather than as a permission error, which is the response to read as the plan or the overage setting refusing rather than as a bug. Turso: List Plans is the node that reads the account's real quota numbers from the API rather than from a pricing page.
Mint a platform API token with the Turso CLI, scoped to the organization you want to automate rather than leaving it unrestricted, since Turso has deprecated unrestricted tokens.
Note the organization slug. The CLI's organization list shows it, and for a personal account it is your username.
In Mattering Automations, open Connectors, click Add Connector, choose Turso, and create a credential with the token and the slug.
Click Test Connection. Mattering reads the organization named by the slug, which validates both halves of the credential in one call: a success reports the organization name and plan, a 401 means the token is bad or expired, a 403 usually means a group-scoped token hitting an organization-level route, and a 404 means the token is fine and the slug is wrong. That last case is the whole reason the test is not a simple token check, because a valid token with a wrong slug would otherwise pass and then fail on 44 nodes at run time.
All 49 Turso nodes appear in the canvas palette. Run Turso: List Groups and Turso: List Databases first: databases are created into groups, so a fresh organization needs a group before anything else works.
Common uses for the Turso MCP
Database per tenant, provisioned end to end
This is the workflow Turso's shape is built for. Turso: Create Database makes a database inside an existing group, Turso: Create Database Token mints a SQL token for it, and the hostname and token go to the tenant. Read the credential warning on that second node rather than around it: the response carries live credential material at data.jwt and it lands in the run's execution record, so send it somewhere it belongs in the same run and treat the record accordingly. Set the token's authorization to read-only for anything that should not write. Because Turso documents no operation-polling endpoint, read the database back with Turso: Get Database before handing out a hostname rather than assuming it is ready.
Branch a database from a point in time
Turso: Create Database takes a seed object, and one of its shapes copies an existing database at a past timestamp, which is how point-in-time recovery works here. Be precise about what that does and does not cover, because the difference matters when it is needed. It creates a NEW database FROM AN EXISTING one, so it protects against mistakes made inside a database that still exists, such as a dropped table or a bad migration: branch to a moment before the mistake, check the branch, then cut over. Nothing in the Platform API reference or Turso's recovery documentation describes restoring a database after it has been deleted, so a delete is not covered by this and the page does not pretend otherwise.
Put replicas where the users are, on purpose
A group is the unit that owns locations: every database inside it replicates to the same set of regions and shares one signing key. Turso: Add Location To Group adds a region and every database in the group gains a read replica there, and Turso: Remove Location From Group takes it away again. That second one loses no data, since the primary still holds everything and adding the location back re-replicates, so it is safe to run in a workflow that reshapes a footprint on a schedule. Location codes come from Turso: List Locations, whose response is a map keyed by the code rather than a list, which is why those fields are typed rather than picked.
Watch usage before the bill or the 402 arrives
Turso bills on rows read and rows written, and three nodes make that visible. Turso: Get Organization Usage reports the current billing cycle with a per-database breakdown, Turso: Get Database Usage takes a window for one database, and Turso: Get Database Stats returns the top queries by rows read and written, which is how you find the expensive query behind a spike rather than guessing. Turso: List Plans reads the account's actual quota numbers from the API. A scheduled sweep can write all of it into a Mattering database and open a task when the trend says a quota will be reached before the cycle ends, which is better than discovering it as an HTTP 402 on a create call.
Credential hygiene as a scheduled job
Turso: List Organization API Tokens is the audit node: it lists the platform tokens scoped to this organization with the member who minted each one, which is how forgotten credentials get found. Turso: Validate API Token checks that the stored token is still valid and reports when it expires. Turso: Revoke API Token and Turso: Revoke Organization API Token close the loop, and both are flagged destructive, because a revoke is immediate, irreversible, and can lock out this connector's own credential if pointed at it. Turso: List Audit Logs is the other half of the picture, with codes covering database and group creation and deletion, token creation, membership changes and plan updates.
Rotate SQL tokens when something leaks
Turso: Invalidate Database Tokens rotates one database's signing key and Turso: Invalidate Group Tokens rotates a whole group's, invalidating every SQL token ever issued against those databases at once. No data is lost and the databases keep running, which is exactly why these are worth understanding precisely: the damage is to availability rather than to storage. Every application, worker and deployment holding an old token starts failing authentication the moment the call returns, there is no grace period, and the old values cannot be brought back. In a database-per-tenant setup the group version logs out every tenant simultaneously. Run them when a token has leaked, in the same workflow that mints and distributes the replacements.
Example: Provision a tenant database and file the result
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a webhook, a form submission or a task status change signals a new tenant, carrying the tenant name.
Turso: List Groups confirms the target group exists and reads its primary location, since databases are created into groups and creating into one that does not exist returns HTTP 400.
Turso: Create Database makes the database. A name already in use returns HTTP 409, and a refusal on quota comes back as HTTP 402 rather than as a permission error, so the workflow branches on both: a 409 appends a suffix and retries, a 402 stops the run and opens a task, because that is a plan decision rather than a retry.
Turso: Get Database reads the record back, because Turso documents no operation-polling endpoint and the create response carries only the name, id and hostname.
Turso: Create Database Token mints a SQL token for that database with authorization set to the narrowest level the tenant needs. The response carries live credential material, so the next step delivers it and the run record is treated as sensitive.
Turso: Update Database Configuration turns delete protection on, so a later delete workflow has to disable it deliberately rather than removing the database by accident.
The hostname and the tenant record land in a Mattering database, and a task opens for a person only when a step reported 402 or 409.
Turso MCP questions, answered
What Turso operations are supported?
All 49 operations in Turso's published Platform API document, as 49 nodes: 25 read and 24 act. Databases (list, get, create, delete, get and update configuration, list and get instances, create database token, invalidate database tokens, usage, stats), groups (list, get, create, delete, get and update configuration, transfer, unarchive, add and remove locations, update the databases in a group, create group token, invalidate group tokens), organization settings, plans, subscription, invoices, usage and audit logs, members and invites, and platform API token listing, creation and revocation, plus identity reads for the token, the user, the organizations it can act on and the available locations. Deliberately not included: SQL query execution, the database file upload, and the unauthenticated closest-region probe, all of which live outside the Platform API document.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. Beyond a chat session, the same nodes run on a schedule or a trigger with nobody present, chain with every other connector in one workflow, hold the platform token in a shared workspace credential store rather than in an individual's config, and carry destructive flags you can gate on.
Turso publishes its own MCP server. Why use this connector?
Turso does, and for some jobs it is the better answer. Turso runs a hosted MCP server for Turso Cloud, authenticated with OAuth so an agent receives a scoped token through the browser rather than a pasted key, covering database management including branching, SQL execution as separate tools for reads, writes, deletes and schema changes, and per-database insight such as top queries. If you want an agent that queries and modifies the data itself, use Turso's server: this connector has no SQL node at all and says so. What this connector covers instead is the rest of the control plane, which its own server does not put on a canvas: groups and replica locations, members, invites and roles, audit logs, plans, subscriptions, invoices and usage, and both token families. And it runs somewhere different: as workflow steps that fire on a schedule or a trigger with nobody present, chained with every other connector, on a credential the workspace holds rather than one developer's client.
Why is there no node that runs SQL against my database?
Because it could not use this credential, and building it would put a live database credential into workflow inputs. Turso runs two independent credential systems and documents them as independent in those words: platform tokens are control-plane credentials for the Platform API, and SQL-engine tokens are what an application uses to query a database, sharing neither key material nor vocabulary. A query node would therefore need a database token pasted or templated into its configuration, landing a working production credential in execution records as an input rather than as a flagged output on a couple of read nodes. If the SQL surface is ever built here it will be a separate connector with its own credential type. Meanwhile Turso: Create Database Token and Turso: Create Group Token mint those tokens for whatever does the querying, and Turso's own MCP server offers SQL tools if that is what you need.
Why does the credential ask for an organization slug?
Because 44 of the 49 operations put it in the URL path, and because Turso scopes its tokens to one organization anyway. The vendor documents unrestricted cross-organization tokens as deprecated and due for removal, tells you to scope new tokens to an organization, and its own client takes an organization and a token together. Putting the slug on the credential rather than on 44 nodes means you never fill a field that does not change, and the dependent pickers for databases, groups, members and tokens work without one. The rejected alternative was resolving it automatically by taking the first organization the API lists, which would silently pick for anyone in more than one and make the failure invisible. If you work across two organizations, create two connections and select the right one on the node.
Can an AI agent delete a database I cannot get back?
Yes, and the recovery story deserves precision rather than reassurance. Turso: Delete Database and Turso: Delete Group are flagged destructive, and the group one is the widest blast radius in the connector: Turso documents delete protection on a group as preventing the group and all its databases from being deleted, so every database inside goes with it, and deleting a group also cascades a revoke to every API token scoped to it. Point-in-time recovery does not cover this. It works by creating a new database from an existing one at a past timestamp, so it protects against mistakes inside a database that still exists, and nothing in the Platform API reference or the recovery documentation describes restoring a database once it has been deleted. What is recoverable is whatever was copied out beforehand. The practical guards are real: delete protection makes both nodes refuse until it is turned off with Turso: Update Database Configuration or Turso: Update Group Configuration, so leave it on and treat turning it off as the deliberate step.
What do the token invalidation nodes actually break?
Availability, not data, and separating the two is the point. Turso: Invalidate Database Tokens rotates one database's signing key and Turso: Invalidate Group Tokens rotates a group's, invalidating every SQL token ever issued against those databases at once. Not one byte is deleted and the databases keep serving, but every application, worker, cron job and deployed environment variable holding a previous token stops authenticating the moment the call returns, there is no grace period, and the old values cannot be restored. In a database-per-tenant setup the group version logs out every tenant simultaneously. Use them when a token has leaked, in a workflow that also mints and distributes the replacements, rather than as routine hygiene. Turso: Revoke API Token and Turso: Revoke Organization API Token do the same to platform tokens, and can revoke the credential this connector is using.
What rate limits should I design around?
Turso documents none, and this page will not invent one. There is no 429 in the published API document, no rate-limit page in the API reference, and no retry-after convention documented, so treat throughput as unknown rather than as unconstrained and build a workflow that would survive being throttled. What Turso does document is a set of response codes worth branching on: 401 for an invalid or expired token, 403 for a valid token without permission, which usually means a group-scoped token hitting an organization-level route, 409 for a resource that already exists, and 402, which is the sleeper. A 402 is neither an auth failure nor a bad request: it means the plan or the overage setting will not permit the operation, so a workflow that has run for months can start returning it the day a quota is reached or the day someone turns overages off. Turso: List Plans reads the real quota numbers.
A scheduled workflow started failing against a group that was fine
Check whether the group was archived. Turso archives groups for inactivity, and an archived group stops serving its databases until Turso: Unarchive Group is called, which makes it a real cause of a workflow breaking after a quiet period rather than after a change. No data is lost by archiving and the group comes back with everything in it, so the fix is a step rather than a rebuild: call the unarchive node and retry. Two other quiet causes worth checking in the same pass. Turso: Update Database Configuration can set block reads or block writes, which makes a database reject client queries until they are turned back off. And Turso: Get Organization reports whether reads or writes are currently blocked account-wide, which explains an otherwise baffling wave of failures across everything at once.
Put Turso to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Turso is a product of its respective owner; Mattering is an independent platform.