canonical: https://jentic.com/apis/appwrite.io/appwrite

# Appwrite

Jentic publishes the only available OpenAPI specification for Appwrite, keeping it validated and agent-ready. Appwrite is an open-source backend-as-a-service that exposes REST APIs for accounts, authentication, document databases, file storage, serverless functions, teams, locale data, and gravatar-style avatars. This combined spec covers 95 operations spanning 65 paths across the full account, database, storage, functions, teams, users, projects, and health surfaces. It is the union of the client-side and server-side Appwrite APIs.

## For AI agents

Open-source backend-as-a-service: accounts, databases, files, serverless functions, teams, and avatars. 95 endpoints across the combined client and server surface.

## Scope

Does not handle payment processing, send transactional email, or run a managed CDN - use for backend account, database, storage, function, and team operations on Appwrite only.

## Capabilities

- Manage user accounts including email, password, sessions, and recovery via /account
- Read, create, update, and delete documents in collections through /database/collections/{collectionId}/documents
- Upload, download, and manage files in storage buckets via /storage/files
- Invoke and manage serverless functions and their executions through /functions
- Create teams, invite members, and manage memberships via /teams
- Generate avatar images, country flags, browser icons, and credit-card art via /avatars
- Read locale data including countries, currencies, and continents under /locale

## Use cases

### Mobile App Backend in a Box

A mobile team uses Appwrite as the backend for a new iOS or Android app - sign-up and login through /account, persistent state in /database collections, user-uploaded files in /storage buckets, and notifications dispatched from /functions. The single Appwrite project replaces a custom Node.js + Postgres + S3 stack and ships in days rather than weeks.

Example prompt: POST /account with email and password to create a user, then POST /database/collections/{collectionId}/documents to write the user's first profile record

### Self-Hosted Document Storage

Teams that cannot send data to managed cloud providers self-host Appwrite and use the database and storage APIs as a private document and file backend. Documents are stored in collections with role-based read/write rules, and files are uploaded to buckets with similar access control. The /health endpoints expose readiness checks for self-hosted deployments.

Example prompt: Upload a PDF to a storage bucket via POST /storage/files, then create a document in /database/collections/{collectionId}/documents referencing the file id

### Serverless Function Orchestration

An automation pipeline triggers Appwrite serverless functions to run business logic - image resizing, webhook fan-out, scheduled reports - without provisioning containers. The /functions API creates functions, manages versions, executes them with payloads, and reads execution logs and status, giving the same control plane as AWS Lambda but tied to the Appwrite project.

Example prompt: POST /functions/{functionId}/executions with a JSON payload, then poll the execution id for status and stdout

### AI Agent Backend Integration

An AI agent uses Jentic to call Appwrite as the backend for an agent-built application - provisioning user accounts, persisting documents, uploading files, and invoking functions. Because Appwrite is open source and Jentic-maintains the only structured spec, agents have a stable, validated tool surface even as Appwrite versions evolve.

Example prompt: Search Jentic for 'create appwrite user', call POST /account, then POST /database/collections/{collectionId}/documents to seed the user's profile

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /account | Create a new user account |
| POST | /account/sessions | Create a new session by email and password |
| POST | /storage/files | Upload a file to a storage bucket |
| POST | /teams | Create a team |
| GET | /users | List users (server-side) |
| GET | /avatars/initials | Generate an avatar from a user's initials |
| GET | /locale/countries | List supported countries |

## Key resources

- **account** — Authenticated user account: email, password, sessions, prefs, recovery
- **database** — Document collections with role-based access rules
- **storage** — File buckets for uploads, downloads, and previews
- **functions** — Serverless functions, executions, and tags
- **teams** — Team creation, memberships, and role management
- **users** — Server-side user administration
- **avatars** — Avatar, flag, browser, and credit-card image generation
- **locale** — Country, currency, language, and continent reference data

## Why Jentic

- **Setup:** Wiring Appwrite by hand means managing the X-Appwrite-Project header plus either a session cookie or a server API key, and mapping its account, database, storage, function, and team operations yourself. Through Jentic you install once, import the Appwrite API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** Most of these Appwrite operations take their target in the request body rather than the URL path, so you limit the agent to the operations it needs, such as creating an account, uploading a file, or reading users. You choose the operations it may call, so team or user writes are not included unless you add them.
- **Credential handling:** Your Appwrite project header and either session cookie or API key are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a user', 'upload a file', or 'list users', and Jentic returns the matching Appwrite operation with its parameters and response schema so the agent calls the right endpoint without navigating the docs site.

## Related APIs

- **Supabase API** — Open-source Firebase alternative with a Postgres-backed database and similar auth/storage/functions surface
- **Firebase API** — Google's hosted backend-as-a-service with a similar account, database, and storage surface
- **Appwrite Server API** — Server-side surface of the same Appwrite API with admin operations

## FAQ

### Why is there no official OpenAPI spec for Appwrite?

Appwrite does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Appwrite via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Appwrite API use?

Appwrite supports two patterns: client-side requests authenticate with the X-Appwrite-Project header and a session cookie obtained through /account/sessions, while server-side requests use an API key in the X-Appwrite-Key header alongside the project header. Through Jentic both flows are vaulted and the agent only sees scoped credentials at execution time.

### Can I store files with the Appwrite API?

Yes. POST /storage/files uploads a file to a bucket, GET /storage/files/{fileId} reads metadata, GET /storage/files/{fileId}/view streams the binary, and DELETE /storage/files/{fileId} removes it. Per-bucket access rules govern who can read and write.

### What are the rate limits for the Appwrite API?

Self-hosted Appwrite has no enforced rate limit beyond your server's capacity. Appwrite Cloud applies plan-based quotas - Free, Pro, and Scale - covering bandwidth, storage, executions, and database operations. Check the Appwrite Cloud pricing page for the exact ceilings on your plan.

### How do I create a user account through Jentic?

Run pip install jentic, search 'create appwrite user', load POST /account, and execute it with email, password, and optional name. Jentic injects the X-Appwrite-Project (and X-Appwrite-Key for server flows) from the vault and returns the new user document.

### Is Appwrite free?

Self-hosted Appwrite is fully open source under the BSD-3-Clause license and free to run on your own infrastructure. Appwrite Cloud has a free tier suitable for hobby projects plus paid Pro and Scale tiers for production workloads.

### Can I limit what my agent is allowed to do with the Appwrite API?

Yes. Because you run Jentic One yourself, your own rules decide exactly which Appwrite operations the agent can call and which credentials it may use. You can allow it to create an account, upload a file to a storage bucket, or read the user list while withholding everything else, and since most Appwrite operations take their target in the request body rather than the URL path, team writes and user administration are not included unless you add them. The stored project header and session cookie or API key are injected only at execution time, so the agent never sees them directly.
