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.
Query
SELECT u.email, o.total, o.status
FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.created_at > now() - interval '1 day'
ORDER BY o.total DESC LIMIT 4;| total | status | |
|---|---|---|
| paige@acme.io | $1,240.00 | paid |
| walter@acme.io | $980.50 | paid |
| happy@acme.io | $642.10 | pending |
| toby@acme.io | $415.00 | refunded |
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.
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.
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.
Serverless
DefaultShared pool. Fast to create, no capacity planning.
Shared compute pool
Dedicated
ProductionIsolated 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.
PgDog
Connection pooler
Connections
48 / 200
Reads
Writes
Reads
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)
Retention 7 days
Restore to a specific moment beyond the latest backup.
Restore time
Sep 30, 14:32:05 UTC
Restore completed
orders-prod · 14:32:05 UTC
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.
team:acme
Team
role:admin
Role
user:owner
User
Rows
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 · teamId: acme
Billing migration
row_02 · teamId: acme
Onboarding emails
row_03 · teamId: acme
Relationships
teams/acme
Acme Engineering
Link related tables without custom joins.
Transaction
Completed- createRow('orders')
- updateRow('teams')
- deleteRow('drafts')
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.
PostgreSQLv17
Extensions, roles, SQL editor
MySQLv8.4
Connections, schemas, and backups
$ psql "$DATABASE_URL"
SSL connection (protocol: TLSv1.3)
app=> CREATE EXTENSION postgis;
CREATE EXTENSION
app=> SELECT count(*) FROM stores
app-> WHERE ST_DWithin(geom, $1, 5000);
count
-------
42
(1 row)
app=> Extensions
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 one remote MCP server.
appwrite
https://mcp.appwrite.ioTerraform
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.
Appwrite Databases include five engines in two categories. Appwrite DBs are TablesDB for relational-style tables and columns, DocumentsDB for flexible JSON documents, and VectorsDB for embeddings and similarity search. Native DBs are managed PostgreSQL and MySQL for teams that need full SQL compatibility, extensions, and portable schemas.
Choose TablesDB, DocumentsDB, or VectorsDB when you want Appwrite SDKs, Console workflows, and Auth-aware permissions out of the box. Choose PostgreSQL or MySQL when you need advanced SQL, existing ORM tooling, extensions such as pgvector, or to run schemas you already operate elsewhere.
Serverless databases run on a shared pool and are the fastest way to start. Billing is usage-based: there is no fixed compute fee, and you pay for storage plus reads and writes against your plan quota (then overage). Dedicated databases provision isolated compute for predictable performance, higher connection limits, and production options such as read replicas, high availability, and point-in-time recovery. Billing is a fixed monthly compute tier per database (from $10/mo), with reads and writes included in the tier. HA replicas and PITR are optional add-ons, and extra storage or bandwidth is billed as overage. You pick a specification when you create the database and can upgrade later.
On serverless databases, replication and high availability are abstracted and managed by the platform, so you do not configure replicas or sync mode yourself. On dedicated databases, traffic can enter through a connection pooler such as PgDog or ProxySQL. A primary instance accepts reads and writes, and read replicas scale query traffic and improve failover resilience. High availability is enabled when replica count is greater than zero. Choose asynchronous, synchronous, or quorum sync mode, and promote a replica from the Console when you need to move write traffic.
Yes on Appwrite Cloud for supported plans and engines. Create automated backup policies or run manual backups from the Backups tab. Point-in-time recovery (PITR) on dedicated databases lets you restore to a specific moment beyond the latest scheduled backup, which helps after accidental deletes, failed migrations, or bad writes.
Yes. TablesDB and DocumentsDB permissions can reference users, teams, and roles from Appwrite Auth at the table, collection, row, and document level. Scope data per customer or workspace without building custom access control.
Yes. Appwrite DBs support filters, ordering, pagination, relationships, transactions, bulk operations, and geo queries through the SDKs and Console. Native PostgreSQL and MySQL databases support full SQL from the in-console editor and your existing SQL clients.
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.