Managed PostgreSQL and databases for every model_
Run managed PostgreSQL next to tables, documents, and vectors. Connect with Prisma or psql, install pgvector, and scale dedicated compute with backups, replicas, and PITR.
Five engines for tables, documents, vectors, and native SQL
- TablesDB
- DocumentsDB
- VectorsDB
- PostgreSQL
- MySQL
Five engines, two categories
Appwrite DBs cover tables, documents, and vectors. Native DBs bring managed PostgreSQL and MySQL when you need full SQL control. Pick the model that matches your data, then operate every engine from the same Console and project.
Appwrite DBs
Managed databases built into Appwrite for app data, documents, and AI workloads.
TablesDB
Relational-style tables, columns, and indexes for structured data and complex queries.
DocumentsDBBeta
Flexible JSON documents with filters and full-text search for evolving schemas.
VectorsDBBeta
Embeddings and similarity search for semantic retrieval and AI features.
Native DBs
Dedicated managed PostgreSQL and MySQL engines you connect to with standard SQL clients.
PostgreSQLBeta
Managed PostgreSQL hosting with full SQL, pgvector, and portable schemas for Prisma, Drizzle, and existing tooling.
MySQLBeta
Familiar MySQL compatibility for common relational apps and migrations.
Serverless or dedicated compute
Start on a shared serverless pool when you want speed and simplicity. Move to dedicated specifications when you need isolated resources, higher connection limits, and production options like replicas and PITR. Choose at create time or upgrade later.
Compute model
Choose how this database is provisioned.
Serverless
Shared pool. Fast to create, no capacity planning.
- Shared compute pool
- Instant provisioning
- Ideal for prototypes
Dedicated
Isolated compute with replicas, HA, and PITR.
- Isolated resources
- Read replicas & HA
- Point-in-time recovery
Replication and high availability
Dedicated databases run behind a connection pooler with a primary for writes and read replicas for query scale and failover. Choose asynchronous, synchronous, or quorum sync mode, then promote a replica when you need to move write traffic.
Proxy · Primary · Read replicas
Backups and point-in-time recovery
Automate encrypted hot backups with policies, or create a manual backup when you need a snapshot now. Enable PITR on dedicated databases to restore to a specific moment after accidental deletes, failed migrations, or bad writes.
Backup policies
EncryptedHot backups with zero downtime and fast recovery.
Hourly
Runs every hour, retained for 24 hours
Daily
Runs every day, retained for 7 days
Point-in-time recovery (PITR)
Restore to a specific moment beyond the latest backup.
Permissions wired to Auth
Scope TablesDB and DocumentsDB access with users, teams, and roles from Appwrite Auth. Set rules at the table, collection, row, or document level so each tenant only sees their data.
Permissions
Scope access with Auth users, teams, and roles.
team:acme
Table
role:admin
Table
user:owner
Row
Queries, relationships, and transactions
Filter, order, and paginate from the SDKs and Console. Model related data with relationships, run multi-step writes in transactions, and use bulk operations when you need to update many rows or documents at once.
Launch checklist
row_01
Billing migration
row_02
Onboarding emails
row_03
Relationships
Link related tables without custom joins.
Transactions
Commit multi-step writes atomically.
Managed PostgreSQL and MySQL
Hosted PostgreSQL and MySQL with standard clients and the in-console SQL editor. Use pgvector, PostGIS, portable schemas, and the ORMs you already run.
PostgreSQL
Extensions, roles, SQL editor
SELECT id, email, plan
FROM customers
WHERE plan = 'pro'
ORDER BY created_at DESC;MySQL
Connections, schemas, and backups
Works with your ORM and toolstack
Use the same connection strings with Prisma, Drizzle, Sequelize, TypeORM, SQLAlchemy, psql, and the rest of your SQL toolchain. Copy ready-made snippets from the Console Connect tab and keep shipping with the stack your team already knows.
Prisma
Type-safe schema and client for Node.js and TypeScript.
Drizzle
Lightweight TypeScript ORM with SQL-like query builder.
Sequelize
Promise-based ORM for Node.js with multi-dialect support.
TypeORM
Active Record and Data Mapper patterns for TypeScript.
SQLAlchemy
Python SQL toolkit and ORM for expressive queries.
psql
Official PostgreSQL CLI for ad-hoc SQL and schema exploration.
Tools built for developers and agents_
API-first by design. Use the Console, Realtime, SDKs, CLI, Terraform, MCP, and agent skills on the same project.
Developer and agent experience
A typical integration in TypeScript.
import { Client, TablesDB, ID } from 'appwrite';
const client = new Client() .setEndpoint('https://<REGION>.cloud.appwrite.io/v1') .setProject('<PROJECT_ID>');
const tablesDB = new TablesDB(client);
const row = await tablesDB.createRow({ databaseId: '<DATABASE_ID>', tableId: 'tasks', rowId: ID.unique(), data: { title: 'Ship v1', done: false },});Everything is an API
REST, GraphQL, and SDKs for every service. Automate and integrate without console-only workflows.
Console
Manage every service in your project from a unified Console. Optimized keyboard access and a Command Center keep you moving fast.
Realtime
Subscribe to live events and react to changes as they happen.
databases.*.tables.*.rows.*
databases.*.tables.*.rows.*.create
MCP
Connect AI agents to your Appwrite project, APIs, and docs through MCP servers.
appwrite-docs
appwrite-apiTerraform
Manage Appwrite infrastructure as code with the official provider.
terraform plan
terraform applyAgent skills
Give AI agents SDK-accurate knowledge of Appwrite services and APIs.
npx skills add appwrite/skillsSDKs
Client and server SDKs for the platforms your team already uses. 15 official SDKs available across client and server runtimes.
CLI
Deploy resources, manage projects, and generate typed SDKs from your terminal.
appwrite login
appwrite deployFAQ_
Yes. Native PostgreSQL databases are dedicated, managed PostgreSQL instances in your project region. You connect with psql, Prisma, Drizzle, or any PostgreSQL driver over TLS. Appwrite provisions compute, backups, replicas, a connection pooler, and point-in-time recovery. PostgreSQL 18 is the default, with 17 also supported.
Start building with Databases_
Create a database, choose your engine and compute model, and query your first data in minutes.
Explore Appwrite_
Modular backend services that share the same project, permissions model, and console.