Mattering Automations Appwrite integration
Connect Appwrite to Mattering Automations: databases, collections, attributes, indexes and documents, storage buckets and files, users, teams and memberships, and function executions as workflow steps, authenticated with your endpoint, project ID and a scoped API key against Appwrite Cloud or a self-hosted install.
The Mattering Automations Appwrite integration adds Appwrite's server REST API to your automation canvas: create and read databases, collections, attributes and indexes, run single-document create, read, update, upsert and delete, manage storage buckets and files including upload from a public URL and locally built download, view and preview links, administer users and their sessions, manage teams and memberships, and run Appwrite Functions and read their execution history.
The credential is three fields, because Appwrite is both a hosted service and a self-hostable one: the API endpoint for your install, the project ID, and an API key created in the Appwrite console on the project's Overview page, under Integration, then API keys. Mattering sends the project ID as an X-Appwrite-Project header and the key as an X-Appwrite-Key header on every request. API keys carry explicit scopes, so the key you mint decides what the integration can reach. Setup takes a few minutes, and this guide walks through each step and ends with the full node reference.
The safety modeling is stated on the nodes rather than buried. Of the 58 nodes, 24 read and 34 act, and eleven carry a destructive flag, because Appwrite does not document a trash or an undo for these deletes, so treat them as final: Appwrite: Delete Database, Appwrite: Delete Collection, Appwrite: Delete Attribute, Appwrite: Delete Index, Appwrite: Delete Document, Appwrite: Delete Bucket, Appwrite: Delete File, Appwrite: Delete User, Appwrite: Delete User Sessions, Appwrite: Delete Team and Appwrite: Delete Membership. Where Appwrite offers a reversible alternative it is built: Appwrite: Update User Status blocks an account without destroying it, and Appwrite: Upsert Document is the idempotent write for a workflow that might be retried.
Before you start
- An Appwrite project, on Appwrite Cloud or on a self-hosted install. Appwrite is open source and self-hostable, and Appwrite Cloud is the hosted option; the integration works against either, because the API endpoint is part of the credential rather than baked into the connector.
- The API endpoint for that install, served over https. Appwrite Cloud regions each answer on their own host and a self-hosted install answers on your own domain. Plain http endpoints are refused, because an API key sent unencrypted can be read in transit.
- Permission to create an API key in the project, which lives in the Appwrite console on the project's Overview page, under Integration, then API keys. The key's scopes are the real boundary on what the integration can do, so whoever creates it should know which node families you intend to automate.
- A Mattering workspace with access to the Automations app.
- Not required and not stored here: end-user session tokens (Appwrite's X-Appwrite-JWT) and anything from the client-side Account API. This integration is server-key auth only, which is the audience Appwrite documents for server SDKs.
Get your Appwrite endpoint, project ID and API key
Mattering authenticates to Appwrite the way Appwrite's REST reference documents for a server: two headers on every request, X-Appwrite-Project carrying the project ID and X-Appwrite-Key carrying an API key, against the endpoint of your install. That third value matters more here than on most connectors. Appwrite Cloud regions and self-hosted installs each answer on a different host, so the endpoint cannot be a constant inside the connector and rides on the credential instead. API keys are minted per project with explicit scopes, so the same three-field credential can be read-only or fully privileged depending on what you tick when you create the key.
Connect Appwrite to Mattering
Verify it works
After connecting, open any automation canvas and check the palette: an Appwrite section should list the query and action nodes. Drop Appwrite: Get Health onto the canvas and run a test step. It is the integration's natural probe: it takes no parameters, needs only the health.read scope, and a clean response means the endpoint, project and key are all wired. If your key was minted without health.read, use Appwrite: List Databases as the probe instead and read the same signal from it.
Next, run Appwrite: List Databases and copy a database ID: it is the value that every collection, attribute, index and document node asks for. Feed it to Appwrite: List Collections, and note the response shape while you are there, because it decides how downstream templates are written. Appwrite wraps lists in an envelope named for the resource rather than a generic one, so the IDs sit at data.databases[].$id and data.collections[].$id, and Appwrite's own managed fields are dollar-prefixed. Everything in this verify path is read-only: it cannot reach any of the eleven destructive nodes, so it is safe to re-run whenever you rotate the key.
Node reference
58 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 24
Appwrite: Get Bucket
appwrite_get_bucket
Fetch one bucket: its permissions, maximum file size, allowed extensions, compression, encryption and antivirus settings.
Appwrite: Get Collection
appwrite_get_collection
Fetch one collection: its name, permissions, document security flag, and its attribute and index definitions.
Appwrite: Get Database
appwrite_get_database
Fetch one database: its name, enabled flag and created date.
Appwrite: Get Document
appwrite_get_document
Fetch one document by ID, with its attributes and Appwrite's own dollar-prefixed fields.
Appwrite: Get Execution
appwrite_get_execution
Fetch one function run: its status, response body and code, duration, logs and errors. This is how an asynchronous execution is polled to completion.
Appwrite: Get File
appwrite_get_file
Fetch one file's metadata: name, MIME type, size, signature and permissions. Returns the record, not the bytes. Use Appwrite: Get File URLs for links to the content.
Appwrite: Get File URLs
appwrite_get_file_urls
Build the download, view and preview URLs for a file, so a workflow can put a link in an email, a message or a task. Appwrite's download, view and preview endpoints return raw bytes, which is not useful as node output, so this node makes NO API call: it assembles the same URLs the Appwrite SDKs build, from the endpoint and project ID on the credential. Whoever opens the link still needs read access to the file, so the file or its bucket must grant read to any for a public link. Preview works on images under 10 MB.
Appwrite: Get Function
appwrite_get_function
Fetch one function: runtime, entrypoint, schedule, timeout, scopes, trigger events and its active deployment.
Appwrite: Get Health
appwrite_get_health
Check that the Appwrite install is reachable and the credential works. Takes no parameters, so it is the cheapest way to verify the endpoint URL, project ID and API key are all correct. The key needs the health.read scope.
Appwrite: Get Team
appwrite_get_team
Fetch one team: its name, member count and preferences.
Appwrite: Get User
appwrite_get_user
Fetch one user account: name, email, phone, verification flags, labels, preferences and registration date.
Appwrite: List Attributes
appwrite_list_attributes
List a collection's attributes (its columns) with each one's key, type, required flag and status. Poll this after creating an attribute: status moves from processing to available, and documents cannot use the column until then.
Appwrite: List Buckets
appwrite_list_buckets
List the project's storage buckets with their IDs, names, size limits and allowed file extensions.
Appwrite: List Collections
appwrite_list_collections
List the collections in one database, with their IDs, names and document security settings.
Appwrite: List Databases
appwrite_list_databases
List the databases in the project, with their IDs and names. The database ID from here feeds every collection, attribute, index and document node.
Appwrite: List Documents
appwrite_list_documents
List documents in a collection. Filtering, sorting and paging all happen through the queries array; the default page is 25 documents, so add limit(...) and offset(...) or a cursor to walk a large collection.
Appwrite: List Executions
appwrite_list_executions
List a function's recent runs with their status, response code, duration and trigger. The default page is 25, so add limit(...) and orderDesc("$createdAt") to walk the history.
Appwrite: List Files
appwrite_list_files
List the files in a bucket with their IDs, names, MIME types and sizes. Filterable on name, signature, mimeType, sizeOriginal, chunksTotal and chunksUploaded.
Appwrite: List Functions
appwrite_list_functions
List the project's functions with their IDs, names, runtimes, schedules and deployment status.
Appwrite: List Indexes
appwrite_list_indexes
List a collection's indexes with each one's key, type, indexed attributes and build status.
Appwrite: List Memberships
appwrite_list_memberships
List a team's members with each membership's ID, the member's name and email, their roles, and whether the invitation is confirmed.
Appwrite: List Teams
appwrite_list_teams
List the project's teams with their IDs, names and member counts. Teams are how Appwrite groups users for permissions.
Appwrite: List User Sessions
appwrite_list_user_sessions
List a user's active sessions with the device, browser, IP and country each one was created from, plus its expiry. Useful for a security review or a suspicious-login alert.
Appwrite: List Users
appwrite_list_users
List the project's user accounts with their IDs, names, emails, verification flags and last-accessed times.
Action nodes 34
Appwrite: Create Boolean Attribute
appwrite_create_boolean_attribute
Add a true/false column to a collection. Returns HTTP 202 while the column is queued. Reversible with Appwrite: Delete Attribute.
Appwrite: Create Bucket
appwrite_create_bucket
Create a storage bucket. Reversible with Appwrite: Delete Bucket while it is still empty.
Appwrite: Create Collection
appwrite_create_collection
Create a collection inside a database. Columns are added afterwards with the Appwrite: Create ... Attribute nodes. Reversible with Appwrite: Delete Collection while it is still empty.
Appwrite: Create Database
appwrite_create_database
Create a database in the project. Reversible with Appwrite: Delete Database while it is still empty.
Appwrite: Create Datetime Attribute
appwrite_create_datetime_attribute
Add a date and time column to a collection. Values are ISO 8601 strings. Returns HTTP 202 while the column is queued. Reversible with Appwrite: Delete Attribute.
Appwrite: Create Document
appwrite_create_document
Create one document in a collection. Every required attribute must be present in the data object, and every key must already exist as an attribute. Reversible with Appwrite: Delete Document.
Appwrite: Create Enum Attribute
appwrite_create_enum_attribute
Add a constrained-choice column to a collection: values must be one of the listed elements. Returns HTTP 202 while the column is queued. Reversible with Appwrite: Delete Attribute.
Appwrite: Create Execution
appwrite_create_execution
Run a function. Leave async off to wait for the result and get the response body back in this node's output; turn it on to queue the run and poll it later with Appwrite: Get Execution. What the run does is up to the function's own code, so treat it as reversible only if the function is.
Appwrite: Create File From URL
appwrite_create_file_from_url
Upload a file to a bucket from a public https URL. Appwrite's own endpoint takes raw bytes and has no create-from-URL variant, so this node downloads the URL (https only, 50 MB cap) and posts the bytes. Reversible with Appwrite: Delete File.
Appwrite: Create Index
appwrite_create_index
Build an index over one or more attributes so queries on them run fast, and so full-text search works at all. Returns HTTP 202 while the index builds. Reversible with Appwrite: Delete Index.
Appwrite: Create Integer Attribute
appwrite_create_integer_attribute
Add a whole-number column to a collection, optionally bounded by a minimum and maximum. Returns HTTP 202 while the column is queued. Reversible with Appwrite: Delete Attribute.
Appwrite: Create Membership
appwrite_create_membership
Add someone to a team. Identify them by existing user ID, by email, or by phone number; supply exactly one. With a server API key and a user ID the membership is created directly, while an email invitation needs a redirect URL. Reversible with Appwrite: Delete Membership.
Appwrite: Create String Attribute
appwrite_create_string_attribute
Add a text column to a collection. Returns HTTP 202: the column is queued, and Appwrite: List Attributes reports when its status reaches available. Reversible with Appwrite: Delete Attribute.
Appwrite: Create Team
appwrite_create_team
Create a team. Reversible with Appwrite: Delete Team. Add people afterwards with Appwrite: Create Membership.
Appwrite: Create User
appwrite_create_user
Create a user account. Supply an email, a phone number, or both; the password is optional and can be set later through Appwrite's own recovery flow. Reversible with Appwrite: Delete User.
Appwrite: Delete Attribute
appwrite_delete_attribute
DESTRUCTIVE and irreversible. Drops a column from the collection, and with it that column's value in every document and any index built on it. Appwrite has no trash and no undo.
Appwrite: Delete Bucket
appwrite_delete_bucket
DESTRUCTIVE and irreversible. Deletes the bucket and every file stored in it. Any URL pointing at those files stops working immediately. Appwrite has no trash and no undo.
Appwrite: Delete Collection
appwrite_delete_collection
DESTRUCTIVE and irreversible. Deletes the collection along with every document, attribute and index inside it. Appwrite has no trash and no undo.
Appwrite: Delete Database
appwrite_delete_database
DESTRUCTIVE and irreversible. Deletes the database along with every collection, attribute, index and document inside it. Appwrite has no trash and no undo.
Appwrite: Delete Document
appwrite_delete_document
DESTRUCTIVE and irreversible. Deletes one document. Appwrite has no trash and no undo, so the row is gone the moment this returns.
Appwrite: Delete File
appwrite_delete_file
DESTRUCTIVE and irreversible. Deletes one file and its stored bytes. Every download, view and preview URL for it stops working immediately. Appwrite has no trash and no undo.
Appwrite: Delete Index
appwrite_delete_index
DESTRUCTIVE. Drops an index. Documents are untouched, but every query that relied on the index starts failing or slows down, and a fulltext search query stops working entirely. Rebuilding a large index takes time.
Appwrite: Delete Membership
appwrite_delete_membership
DESTRUCTIVE. Removes someone from a team. Their account survives, but every permission granted through team:<id> stops applying to them at once, so anything scoped to the team becomes invisible. Re-adding them means a fresh invitation.
Appwrite: Delete Team
appwrite_delete_team
DESTRUCTIVE and irreversible. Deletes the team and every membership in it. Any permission string granting access to team:<id> stops matching, so documents and files scoped to this team become unreachable for its former members. Appwrite has no trash and no undo.
Appwrite: Delete User
appwrite_delete_user
DESTRUCTIVE and irreversible. Deletes the account along with its sessions, identities, targets and team memberships. Documents and files the user created are NOT removed. To stop someone signing in without losing the account, use Appwrite: Update User Status instead.
Appwrite: Delete User Sessions
appwrite_delete_user_sessions
DESTRUCTIVE. Signs the user out of every device at once by deleting all of their sessions. The account itself is kept, but the sessions cannot be restored and the person must sign in again everywhere.
Appwrite: Update Collection
appwrite_update_collection
Update a collection's name, permissions, document security flag or enabled state. This is a PUT: read the collection first and resend the values you want to keep, because an omitted permissions array clears the collection's permissions.
Appwrite: Update Document
appwrite_update_document
Update an existing document. This is a PATCH, so only the keys present in the data object are changed and the rest of the document is left alone. Fails if the document does not exist.
Appwrite: Update Membership Roles
appwrite_update_membership_roles
Set the roles on one team membership. The array REPLACES the member's current roles, so include every role they should keep.
Appwrite: Update Team Name
appwrite_update_team_name
Rename a team. Memberships are unaffected.
Appwrite: Update User Email
appwrite_update_user_email
Change a user's email address. The new address must be unique in the project, and changing it resets the account's email verification flag.
Appwrite: Update User Name
appwrite_update_user_name
Change a user's display name.
Appwrite: Update User Status
appwrite_update_user_status
Block or unblock a user account. A blocked account cannot sign in, but its data, memberships and files are kept, so this is the reversible alternative to deleting the user.
Appwrite: Upsert Document
appwrite_upsert_document
Create the document if that ID is free, or replace it if it is already taken. Because it replaces rather than merges, send the whole document body. This is the idempotent write: re-running a workflow with the same ID produces one document, not two.
Using the integration
On the automation canvas
Appwrite nodes chain with every other node in Mattering: an inbound webhook can run Appwrite: Create User and then Appwrite: Create Membership to place the account in the right team, a scheduled sweep can read Appwrite: List Documents and open a task in Mattering Productivity for every row that needs attention, and Appwrite: Create Execution can hand work to a function you already deployed. The database ID from Appwrite: List Databases and the collection ID from Appwrite: List Collections are the two values almost every downstream Databases node asks for, and the pickers on those fields chain: choose a database and the collection picker fills itself from it.
From AI assistants over MCP
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can drive the same surface. An agent can read a collection's shape with Appwrite: List Attributes, write a correctly shaped row with Appwrite: Create Document, find the file it needs with Appwrite: List Files and hand out a link from Appwrite: Get File URLs. The read nodes are the safest surface to give an agent, and Appwrite gives you a second lever the canvas cannot: mint the credential's API key with read-only scopes and the writers are refused at the API rather than by convention. Appwrite also runs its own official remote MCP server at mcp.appwrite.io, which an assistant connects to over OAuth with no API key, plus a separate MCP server for its documentation. Those are aimed at a person in a conversation, authenticated as themselves. These nodes cover the other half of the job: they run on a schedule or a trigger with nobody present, they chain with other apps' nodes in a single workflow, they authenticate with a scoped API key held as a shared workspace credential rather than an individual's login, so a workflow keeps running when that person is away, and the destructive ones carry a flag on the node before the step runs. Running both is a reasonable setup.
Tables, columns and rows: Appwrite's newer naming
Appwrite's TablesDB API renames the Databases vocabulary: collections became tables, attributes became columns and documents became rows. The console you open uses the new words, and the API key scopes are already renamed, which is why you tick tables, columns and rows when you create the key. The node names in this integration keep the older wording because they call the legacy methods, which still work and still receive maintenance. When you are comparing the canvas against the console, read Appwrite: List Collections as tables, Appwrite: List Attributes as columns and Appwrite: List Documents as rows.
Creating columns is asynchronous, so poll
This is the one Appwrite behavior that changes how a workflow is built. Attribute and index creation answer HTTP 202: the column or index is queued, and its status moves from processing to available in the background. A workflow that runs Appwrite: Create String Attribute and immediately runs Appwrite: Create Document using that key will fail, because the column does not exist yet. Put Appwrite: List Attributes between them and wait for the status to reach available. The five creators built here are Appwrite: Create String Attribute, Appwrite: Create Integer Attribute, Appwrite: Create Boolean Attribute, Appwrite: Create Datetime Attribute and Appwrite: Create Enum Attribute, covering text, number, flag, date and constrained choice; Appwrite: Create Index follows the same queued pattern for the fields your queries will filter or search.
Three ways to write a document, and when each fits
Appwrite: Create Document requires every required attribute and rejects any key that is not already an attribute, so it suits a form submission whose shape you control. Appwrite: Update Document is a PATCH: only the keys you send change, and the call fails if the document does not exist, which makes it the right choice for touching one field on a known row. Appwrite: Upsert Document creates the document if the ID is free and replaces it if it is taken, so it sends the whole body rather than a patch, and it is the write to reach for whenever a workflow might run twice: re-running produces one document, not two. All three take the data object, and template references resolve inside it, so values from earlier steps can be dropped into individual fields.
The queries array is a grammar, not a search box
Every lister takes a queries array, and each element is one string in Appwrite's own query language: limit(25), offset(50), orderDesc("$createdAt"), equal("status", ["active"]), select(["$id","name"]), cursorAfter(...), plus contains, between, isNull, startsWith, and, or. Appwrite accepts at most 100 elements, each up to 4096 characters long. The default page is 25, so Appwrite: List Documents and Appwrite: List Executions both need an explicit limit before they will show you more, and a sweep over a large collection walks with offset or a cursor. Several listers, among them Appwrite: List Databases, Appwrite: List Users and Appwrite: List Files, also take a plain search string; those are the fields whose canvas pickers offer a search box, and the ones without a search field deliberately do not pretend to have one.
Files, links, and the bytes that stay out of node output
Appwrite: Create File From URL uploads by fetching a public https URL and posting the bytes, because Appwrite's own create-file endpoint takes multipart bytes and has no create-from-URL variant. It is a single-shot upload with a 50 MB cap; larger files belong in the SDK's chunked upload or the console. On the read side the split is deliberate: Appwrite: Get File returns the metadata record, and Appwrite: Get File URLs builds the download, view and preview links locally, with no API call at all, from the endpoint and project ID on the credential. Appwrite's download, view and preview endpoints return raw bytes, which is not usable node output, so the link is what a workflow puts in an email, a message or a task. Whoever opens that link still needs read access, so a genuinely public link means the file or its bucket grants read to any.
Users, teams, and the permissions that follow them
Teams are how Appwrite groups users for permissions, so team writes are access changes. Appwrite: Create Membership adds someone by existing user ID, by email, or by phone number, and with a server key plus a user ID the membership is created directly while an email invitation needs a redirect URL. Appwrite: Update Membership Roles replaces the member's roles rather than adding to them, so send every role they should keep. On the user side, Appwrite: List User Sessions shows the device, browser, IP and country behind each active session, which is the read a suspicious-login alert runs on, and Appwrite: Delete User Sessions signs the person out everywhere while keeping the account.
Functions: run and watch, deploy elsewhere
Appwrite: List Functions and Appwrite: Get Function show runtime, entrypoint, schedule, scopes and active deployment, and Appwrite: Create Execution runs one. Leave async off and the node waits and returns the function's response body inline, which suits a short transform mid-workflow; turn it on and the run is queued, so a later step polls Appwrite: Get Execution for status, response code, duration and logs. Appwrite: List Executions gives a monitoring job the history it needs. Creating, updating and deleting functions and their deployments is deliberately out of scope: a function created over the API has no deployment and no way to add one from a config panel, and deleting one destroys its deployments and execution log, so that work belongs in git, the CLI or the console.
What is deliberately not here
Messaging, because providers, topics, subscribers and messages are a large surface where each provider type needs its own credential shape and a send is an irreversible fan-out. Bulk document writes and the increment and decrement helpers, because they take arrays of whole documents or a filter that decides how many rows get rewritten. Transactions, because the transaction ID they need comes from an API this integration does not expose. Attribute updates, because the update endpoint takes the required flag and the default as parameters that are sent together on every call, so an edit meant to change one of them can change the other; delete and recreate is the honest path. Password writes, so no plaintext password travels through node config or execution logs; Appwrite's own recovery flow covers that. Locale, because those endpoints report the caller's geolocation, which from our servers describes us rather than your user. And Avatars, Sites, Migrations, Proxy, Tokens, VCS, the console-only Project API and the client-side Account API are out of scope for a server-key connector.
Troubleshooting
Test Connection fails with a 401
One family of nodes is refused while everything else works
Saving the credential is rejected because of the endpoint
A create-document step fails saying an attribute is unknown
A list node returns 25 items when there are far more
A delete node returns no data and the next step gets nothing
A file link works for you and 404s or 401s for the recipient
Create Database or Create Bucket is refused on a Free Appwrite Cloud project
A bulk upload or cleanup starts getting refused
Deleting the wrong thing, and what it costs
Related
The Appwrite MCP
What connecting Appwrite unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
Appwrite is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.