Menu

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.

Sign in to the Appwrite console and open the project you want to automate.
Open Project settings and copy the Project ID. Note the API endpoint the console shows for the project as well; on Appwrite Cloud it is a regional host, and on a self-hosted install it is your own domain.
Leave settings and open the project's Overview page. Find the Integration section, open API keys, and click Create API key. Give it a name that says where it is used, such as Mattering Automations.
Select the scopes for the node families you intend to automate. Databases nodes read and write through the databases, tables, columns, indexes and rows scopes, Storage through buckets and files, the Users nodes through users, Teams through teams, Functions through functions and execution, and the connection probe through health.read.
Scopes are the real permission boundary, not a formality. A key created with only databases.read and rows.read will run every reader in this integration and be refused by every writer, which is a clean way to give an AI agent a look at production without giving it a way to change it.
Copy the key value.
Treat the API key as a server secret. Appwrite's own REST reference warns not to use an API key in client applications, because it is not scoped to a single end user. If a key leaks, delete it in API keys and create a replacement. Deleting a key revokes it, and this integration is using it, so create the replacement and update the credential in the same sitting rather than leaving the workflows to fail. The API keys screen lives on the project's Overview page under Integration.

Connect Appwrite to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Appwrite from the list.
Click Create new credential and fill the three fields: Endpoint with your install's API endpoint, Project ID with the value from Project settings, and API Key with the key you just created. Save.
The endpoint is normalized rather than taken literally. A bare hostname gets https added, a missing API version suffix is appended, trailing slashes are stripped, and a pasted deeper path such as a link to the databases route is trimmed back to the API root. Plain http is refused rather than upgraded, so if a self-hosted install has no certificate yet, sort that out before connecting.
Click Test Connection. Mattering calls Appwrite's health endpoint, which takes no parameters: a success proves the endpoint URL, the project header and the key header are all correct together, and a 401 carrying Appwrite's structured error body means one of the three is wrong.
Click Connect. All 58 Appwrite nodes appear in your canvas palette.

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
Appwrite returns 401 with a structured error body when any part of the server credential is wrong, and the probe deliberately exercises all three at once. Check the API Key first for whitespace picked up in the copy, and confirm the key still exists on the project's Overview page under Integration > API keys, because deleting a key revokes it. Then check the Project ID matches the project the key was created in, because a key is only valid for its own project. Then check the Endpoint points at the install that project lives on; an Appwrite Cloud project reached at the wrong regional host, or a self-hosted domain typed from memory, fails here in exactly the same way. If the key was minted without health.read, the probe alone can fail while the rest of the integration works, so re-test with a reader such as Appwrite: List Databases before assuming the credential is bad.
One family of nodes is refused while everything else works
That is a scope miss, not a broken credential, and Appwrite says so: the response is an authorization error naming the scope the key is missing. Appwrite API keys carry explicit scopes chosen at creation, so a key with databases.read and rows.read runs every reader and is refused by every writer, and a key minted for the Databases family cannot touch users no matter which node calls it. Open the project's Overview page, go to Integration > API keys, edit the key, and add the scopes for the family that is failing: databases, tables, columns, indexes and rows for Databases, buckets and files for Storage, users for the Users nodes, teams for Teams, functions and execution for Functions. Sometimes the right fix is the opposite one: if a workflow is being refused on a write you did not intend it to make, the read-only key is doing its job.
Saving the credential is rejected because of the endpoint
The endpoint is normalized before it is stored, and one case is refused outright. A bare hostname gets https added, a missing API version suffix is appended, trailing slashes are stripped, and a pasted deeper path is trimmed back to the API root, so most copy-and-paste mistakes are fixed for you. A plain http endpoint is refused rather than upgraded, because the API key travels in a header on every request and would be interceptable. If a self-hosted install is still on plain http, put a certificate in front of it before connecting; if it is behind a reverse proxy, use the public https address rather than the internal one.
A create-document step fails saying an attribute is unknown
Almost always the queued-column race. Attribute creation answers HTTP 202: the column is queued and its status moves from processing to available in the background, so a workflow that creates the attribute and writes a document in the next step gets there first. Insert Appwrite: List Attributes between the two and wait for the status to read available. The other cause is simpler: Appwrite: Create Document rejects any key in the data object that is not an attribute on the collection, so a typo in a field name looks like the same error. Run Appwrite: List Attributes and compare the keys.
A list node returns 25 items when there are far more
That is Appwrite's default page, not a truncated response. Every lister pages at 25 unless the queries array says otherwise, so add limit with the size you want, and walk the rest with offset or a cursor from Appwrite's own grammar. The array is capped at 100 elements, each up to 4096 characters long, which is generous for paging but worth knowing if a workflow is generating query strings. The same default is why a canvas picker can look short on a big project: the pickers request a larger page than the default so the dropdown is not capped at 25, but a collection with thousands of rows is still not a dropdown problem, it is a query.
A delete node returns no data and the next step gets nothing
Appwrite answers deletes with HTTP 204 and an empty body, which Mattering surfaces as a success with an empty data object rather than inventing a response. That is the expected shape for every one of the eleven destructive nodes: success is the status itself. If a downstream step needs the deleted object's details, read them before the delete rather than after, for example with Appwrite: Get Document or Appwrite: Get File, and carry the values forward.
A file link works for you and 404s or 401s for the recipient
Appwrite: Get File URLs builds the download, view and preview links locally from the endpoint and project ID; it makes no API call and cannot grant access. Whoever opens the link still authenticates against Appwrite's own permissions, so a link that is genuinely public needs the file, or the bucket it sits in, to grant read to any. Check the file's permissions with Appwrite: Get File and the bucket's with Appwrite: Get Bucket before sending a link outside the project. The preview URL has a further limit worth knowing: it works on images, and only up to 10 MB.
Create Database or Create Bucket is refused on a Free Appwrite Cloud project
That is a plan quota rather than a bug. Appwrite Cloud's Free plan allows one database, one bucket and two functions per project, so a workflow that provisions its own containers runs out on the second one. Free projects also pause after a week of inactivity, which is worth knowing for a scheduled workflow that only runs occasionally. The pattern that works on a Free project is to create the database and the bucket once in the console and have the workflow write into them: Appwrite: Create Collection, Appwrite: Create Document and Appwrite: Create File From URL all live inside containers that already exist, so only Appwrite: Create Database and Appwrite: Create Bucket hit the ceiling.
A bulk upload or cleanup starts getting refused
A rate limit is an unlikely cause here. Appwrite rate limits per route, keyed on the IP, the method, the URL and the user ID, and its documentation says those limits apply to client applications and do not apply to requests authenticated with a server API key, which is how this integration authenticates. So read the error body on the node output rather than assuming throttling. The likelier causes are a scope miss on the key for the family that started failing, a plan quota on the resource being created, or, on a self-hosted install, an abuse setting configured by whoever operates it. When a call is refused the node reports the error on its output instead of retrying silently, so a workflow can branch, wait, and continue.
Deleting the wrong thing, and what it costs
Appwrite does not document a trash or an undo for these deletes, so treat the eleven destructive nodes as final the moment they return, with a backup on a paid plan sometimes the only recovery path. Appwrite: Delete Database takes every collection, attribute, index and document inside it. Appwrite: Delete Collection takes its documents, attributes and indexes. Appwrite: Delete Attribute drops that column's value in every document and any index built on it. Appwrite: Delete Bucket removes every file and breaks every URL pointing at one. Appwrite: Delete Team stops every permission granted through that team from matching, so documents and files scoped to it become unreachable for its former members. Two of them have gentler alternatives that are usually what you actually wanted: use Appwrite: Update User Status to block an account instead of Appwrite: Delete User, and Appwrite: Delete User Sessions to sign someone out everywhere while keeping their account. For the rest, the pattern is read or export first, then put the delete behind a condition, an approval task, or a manual run rather than a bare trigger.

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.

Start Free Explore our Products