Skip to content
Start building

Changelog

  • Announcing CSV exports: Effortless data extraction, right from your Console

    Appwrite now supports exporting data to CSV directly from the Console. This feature simplifies data extraction and reporting without requiring SDKs or custom scripts.

    What's new

    CSV export introduces a new option in the Appwrite Console for downloading CSV files from your database tables.

    That means, you can:

    • Apply filters or queries before export.
    • Choose specific attributes (columns) to include.
    • Set a custom delimiter and optional header row.
    • Run exports asynchronously in the background.
    • Receive email notifications with a short-lived download link once the export completes.
    • Export relationship fields as IDs by default.

    Immediate benefits:

    • Enables data export without SDKs or scripts.
    • Customizable exports with query filters and column selection.
    • Non-blocking execution via background jobs.
    • Secure: Exports respect Appwrite's document permissions.
    • Supports standard CSV formatting options (delimiter, headers, filenames).

    Now live on Appwrite Cloud.

    Read the announcement to learn more

  • GraphQL schema is now public

    You can now run introspection queries on Appwrite's GraphQL API. With introspection enabled, you get:

    • IDE autocomplete for queries, mutations, and fields
    • Schema exploration using tools like GraphQL Playground, Insomnia, or Postman
    • Type generation for strongly-typed clients in your preferred language

    Here's how to fetch the schema using the Appwrite SDK:

    Web
    import { Client, Graphql } from "appwrite";

const client = new Client()
    .setEndpoint('https://<REGION>.cloud.appwrite.io/v1')
    .setProject('<PROJECT_ID>');

const graphql = new Graphql(client);

const schema = await graphql.query({
    query: `{
        __schema {
            types { name }
            queryType { fields { name } }
            mutationType { fields { name } }
        }
    }`
});

console.log(schema.data);

    Learn more about Appwrite's GraphQL API

  • Announcing Screenshots API: Generate pixel-perfect webpage screenshots on demand

    We're excited to announce the Screenshots API, a new addition to Appwrite Avatars that lets you generate fully customizable webpage screenshots with a single API call.

    No more headless browser infrastructure to maintain. No more environment-specific workarounds. Just simple, reliable screenshot generation.

    What you can do

    • Capture any public webpage as an image
    • Simulate an authenticated experience via custom request headers
    • Control browser viewport size and device scale
    • Render in light or dark theme
    • Simulate different locales, timezones, and geolocation
    • Pre-grant browser permissions
    • Generate full-page or viewport-only screenshots
    • Customize output format, dimensions, and quality

    The Screenshots API is available today as part of Appwrite Avatars and is already being used in production by Imagine.

    Get started with Screenshots API

  • Free plan function limit reduced to 2

    Starting today, the Free plan now allows a maximum of two functions per project, reduced from the previous limit of five.

    What does this mean for developers on the Free plan?

    If you currently have more than two functions in your project on the Free plan, you'll continue to have full access to all of them for now. However, you won't be able to create new functions until you reduce the count or upgrade to a paid plan.

    Why this change?

    We've observed increasing abuse on the platform, including users running torrents, long-lived traffic that resembles attacks, and other misuse of the platform as free hosting for non-stop jobs. By reducing the number of free functions, we're making it harder for bad actors to exploit the platform while keeping Appwrite stable and fair for developers building legitimate applications.

    Appwrite's Free plan continues to provide all the core building blocks you need to build real applications, including Databases, Authentication, Storage, Functions, Messaging, and Sites.

    If you have questions or need help planning your migration, please contact us at billing@appwrite.io.

    Learn more about Appwrite Functions

  • Announcing Appwrite 1.8.1 for self-hosted deployments

    After multiple updates and fixes, we have now released Appwrite 1.8.1 for self-hosting!

    Most notably, this release includes:

    • Added branch-only deployments support
    • Added TanStack Start sites support
    • Added Next.js standalone support
    • Added Resend integration
    • Added option to enable/disable image transformations per-bucket
    • Added operators support
    • Added function and sites stats
    • Added disable count feature
    • Added ElevenLabs site template
    • Added suggested environment variables
    • Updated GeoDB database
    • Updated Flutter default build runtime
    • Upgraded runtimes

    Head over to our migration guide to learn how you can upgrade your Appwrite instance. Please run the migrate command even if upgrading from 1.8.0.

    For the complete list of updates and fixes, check out the release notes on GitHub.

    Upgrade your self-hosted instance

  • Announcing Full Schema Creation: Provision complete tables in one atomic call

    Introducing a new Database feature called Full Schema Creation.

    With Full Schema Creation, you can define an entire table, its attributes and indexes, in a single, synchronous request. When the call returns, the table is immediately ready for reads and writes. If anything fails along the way, nothing is created. No partial schemas. No waiting. No brittle setup scripts.

    Read the full announcement

  • Fixed file token URL consistency for non-expiring tokens

    File tokens allow you to generate custom URLs for accessing files in Storage buckets.

    We've fixed two issues with non-expiring file tokens:

    • Unexpected expiration: Non-expiring tokens were incorrectly expiring after 15 minutes, despite being configured to never expire.
    • Inconsistent URLs: Each request generated a different URL for the same non-expiring token, breaking caching and causing unnecessary revalidation.

    With this fix:

    • Non-expiring file tokens now generate consistent URLs across all requests.
    • URLs remain valid indefinitely as intended.
    • Improved reliability for long-term file sharing and caching strategies.

    This update is now live on Appwrite Cloud.

    Join the conversation on Discord

  • Database AI suggestions

    This release introduces AI-assisted schema generation to simplify database schema creation.

    What’s new:

    • Added Database AI suggestions in the Console
    • Automatic column and index suggestions based on table name and context
    • Added sample data generation when creating a new table, allowing you to quickly populate example records that match the schema
    • Example: Creating a table called Orders suggests columns orderId, userId, totalAmount, and status

    Benefits:

    • Faster setup: Define schemas in seconds instead of manually creating each column
    • Consistency: Field names and types aligned across tables
    • Best practices: Suggested indexes and common fields included by default
    • Flexibility: Suggestions can be reviewed, modified, or skipped before applying

    This update is available now on the Appwrite Console.

    Read the announcement to learn more

  • You can now disable image transformations for buckets

    You can now disable image transformations for any storage bucket.

    Image transformations allow actions like resizing, cropping, and format conversion through the Appwrite Storage API. With this update, you have full control to turn off these operations when they're not needed, reducing the chance of unintentional processing or costs.

    This update is useful if you:

    • Want to avoid unexpected transformation charges.
    • Need to restrict buckets to serve only original files.
    • Want greater control over how images are accessed and displayed.

    You can find the toggle in your bucket settings under Image transformations.

    Join the conversation on Discord

  • Skip total counts for faster list queries

    You can now skip totals with a simple total=false flag and get faster, lighter list responses without the extra database work.

    What’s new

    • Added a new request flag: total=false on all list* endpoints
    • When enabled, Appwrite skips the COUNT query entirely
    • Response includes total: 0 while still returning items normally
    • Fully backwards-compatible: default behaviour remains unchanged
    • Works best with cursor-based pagination
    • Applies consistently across all list-like API calls

    Immediate benefits

    • Faster API responses for large and filtered result sets
    • Lower database and CPU load, improving stability under heavy read traffic
    • Better UX for infinite scroll and mobile clients that don’t rely on totals
    • Reduced cloud infrastructure cost by avoiding unnecessary COUNT operations

    This feature is now live on both Appwrite Cloud and Self-hosted instances

    Learn more from the documentation

  • Announcing DB operators: Update multiple fields without fetching the entire row

    Updating just one field in a row, like incrementing a counter or adding a tag, used to require reading and rewriting the entire document. This added latency, wasted bandwidth, and created risks of lost updates under high concurrency.

    What’s new:

    • Introduced DB Operators v1, enabling inline, atomic field-level updates.
    • Support for numeric, array, string, and date operations.
    • Perform multiple field updates in a single atomic call.
    • Type-safe SDK methods for clarity and safety.
    • Transaction-ready, can be combined with other database operations.

    Immediate benefits

    • Always consistent. No race conditions or lost updates.
    • Lower latency and bandwidth usage.
    • Cleaner, more expressive code. One call, clear intent.
    • Composable updates across multiple fields.

    Live now on Appwrite Cloud. Coming soon to self-hosted deployments.

    Read the announcement to learn more

  • Next.js 16 Support (Server-Side Rendering)

    Appwrite Sites now fully supports Next.js 16, including Server-Side Rendering (SSR) and the latest framework improvements such as Cache Components, Turbopack, and refined caching APIs.

    You can deploy applications built with Next.js 16 directly on Appwrite Sites with zero configuration changes.

    Highlights:

    • Full SSR compatibility with Next.js 16.
    • Built-in support for static, dynamic, and hybrid rendering modes.
    • Optimized deployment flow using Turbopack for faster build times.

    This update ensures seamless deployment and improved performance for all projects using the latest Next.js release.

    Deploy a Next.js app to Appwrite Sites

  • Appwrite Sites now offers unlimited sites on the free plan

    When we launched Appwrite Sites in early access, our goal was clear: make deploying modern web projects as easy and integrated as building them. From the start, we intended for developers to have full flexibility, to deploy, test, and scale without limits.

    But before opening things up, we needed to ensure that the platform was stable, fast, and reliable for everyone. That’s why, during the initial rollout, we limited Sites to one per project. This gave us the room to validate performance, harden our infrastructure, and refine the developer experience.

    Now that Appwrite Sites has matured, it’s time to lift that constraint. On the free plan, you can deploy unlimited sites per project.

    Read the announcement

  • New Cloud regions announced: Singapore and Toronto

    We’ve expanded the Appwrite Cloud to two brand-new regions!

    Starting today, the Singapore (SGP) and Toronto (TOR) regions are live and ready for your projects.

    This means you can: Create new projects directly in the regions SGP or TOR.

    Or migrate your existing projects to take advantage of these new locations.

    If your users are based in Southeast Asia, the Singapore region will help you deliver a faster and more reliable experience. If your users are in Canada or the U.S. Northeast, the Toronto region will help you do the same, closer to where your users are.

    Learn more about regions

  • Appwrite Sites now supports TanStack Start

    TanStack Start is quickly becoming the go-to framework for developers who want simplicity, type safety, and performance without the overhead.

    And now, Appwrite Sites brings full Server-Side Rendering (SSR) support for TanStack Start, making it easier to build, run, and deploy modern React and Solid apps on Appwrite Cloud.

    What’s new

    • Full SSR support for TanStack Start: Deploy TanStack Start apps directly on Appwrite Cloud with zero configuration.
    • Native Cloud support: Everything works out of the box on Appwrite Cloud, no additional setup required.

    It’s now available on Appwrite Cloud.

    Read the announcement to learn more

  • Email verification for Cloud accounts

    Email verification is now required for all new and existing accounts on Appwrite Cloud.

    As a new user, if you create your account using an email and password, you will be prompted to verify your email address during the signup process.

    As an existing user, if you have not yet verified your email address, you will be prompted to verify your email address the next time you access the Appwrite Console.

    If you have any questions or need assistance, please create a support post on Discord.

    Open Discord

  • Self-hosted Appwrite 1.8.0 is now available

    Self-hosted Appwrite 1.8.0 is now available, bringing a host of new features, improvements, and bug fixes to enhance your experience.

    Some of the key highlights include:

    • Added Flutter 3.32 and Dart 3.8 runtimes
    • Added increment + decrement routes
    • Added support for React Native schemes
    • Updated origin validation for web extensions
    • Added CSV imports
    • Added realtime support for the Bulk API
    • Added native sign in with Apple function template
    • Added TablesDB service
    • Added spatial type attributes
    • Added support for transactions
    • Updated SMTP Messaging emails to send using BCC

    Refer to the release notes for the full list of changes.

    Upgrade your self-hosted instance

  • Announcing Transactions API: Reliable multi-record writes across tables

    Handling multi-step workflows across tables often means dealing with partial writes and manual rollback logic.

    With the new Transactions API, you can now execute multiple operations as a single atomic action, either all succeed or none do.

    What's new:

    • New Transactions API for managing multi-step writes
    • Support for staging multiple create, update, and delete operations across tables
    • Atomic commit and automatic rollback on failure
    • Configurable timeout for idle transactions (default: 5 minutes)

    Benefits:

    • ACID compliance: Ensures atomicity, consistency, isolation, and durability across all staged operations.
    • All-or-nothing writes: Prevents partial data states and inconsistent records.
    • Automatic rollback: Appwrite handles cleanup on failure, no manual scripts required.
    • Reduced race conditions: All operations are validated and committed together.
    • Simplified logic: Consolidate multi-table operations without adding client-side complexity.

    This update is live on Appwrite Cloud.

    Read the announcement to learn more

  • Performance improvements for Functions and static sites

    We've shipped major performance improvements across functions and static sites.

    Function cold starts are now 58% faster in the Frankfurt (FRA) region with more consistent start times across executions.

    Static sites are now served directly through our edge proxies, eliminating the need for dedicated runtimes. This means:

    • No more cold starts for static sites
    • Automatic caching for all static site assets
    • Over 99% of requests served locally from 120+ global PoPs

    These improvements are now live on Appwrite Cloud. Please don't hesitate to share your experience and feedback with us.

    Join the discussion on Discord

  • Announcing API for spatial columns: Build scalable location-aware apps with ease

    Working with geo data usually means storing raw coordinates and writing custom logic that slows down as your dataset grows.

    But now, you can build scalable geo workflows right out of the box.

    What's new:

    • New column types: Point, Line and Polygon
    • New index type: Spatial
    • 12 new geo query operators: crosses, notCrosses, distanceEqual, distanceNotEqual and more.

    Benefits:

    • Native support for geo logic: Handle geofencing, routing, and compliance zones without custom hacks.
    • Scales with your data: Spatial indexes keep queries fast even with a large volume of records.
    • Simpler development: Reduce app-side complexity by keeping geo operations inside the database.

    This update is live on Appwrite Cloud.

    Read the announcement to learn more

  • Announcing Turbopack support for Appwrite Sites

    Appwrite Sites now supports Next.js applications built with Turbopack, with faster builds and better compatibility for your deployments.

    What's new

    • Turbopack support: Deploy Next.js SSR sites using Turbopack bundler for faster builds
    • Better Next.js compatibility: Developers no longer need to disable Turbopack in build commands

    Benefits

    • Faster builds: Turbopack is faster than webpack
    • Better developer experience: No build configuration changes needed when deploying applications that use Turbopack

    This update is live for all Appwrite Cloud users. Self-hosted support will come in an upcoming release.

    Learn more in the announcement post

  • Introducing the Appwrite MCP server for docs

    While the Appwrite docs are constantly getting updated and improved, LLMs often struggle to provide accurate and up-to-date information due to missing context.

    Appwrite's new MCP server for docs solves this problem by enabling AI assistants to access and search through Appwrite's documentation directly.

    With this MCP server, AI assistants can:

    • Search through Appwrite documentation
    • Retrieve specific guides and references
    • Generate code snippets using the latest APIs
    • Provide contextual help for Appwrite features

    This makes it easier for developers to get instant, accurate answers about Appwrite directly from their AI development environment.

    Learn more in the documentation

  • Announcing inversion queries: Exclusion rules made simple

    Excluding data often meant fetching too much and then filtering it out in your app, which wasted reads and added extra logic.

    To make those exclusions simpler and more efficient, we’ve added inversion queries:

    • notSearch
    • notContains
    • notBetween
    • notStartsWith
    • notEndsWith

    With these, you can express “everything except …” rules directly in your queries, keeping them cleaner, reducing wasted reads, and cutting down on payload sizes.

    Now live on Appwrite Cloud + Self-hosted.

    Read the announcement to learn more

  • Announcing time helper queries: Cleaner, more expressive time-based queries

    A new set of database queries, time helper queries, is now live.

    Filtering by time is one of the most common patterns in real-world apps. Until now, this often meant adding extra conditions that made your queries longer and harder to read.

    With time helper queries, you can now handle time-based filtering in a simple and expressive way. You’ll find four new options:

    • createdBefore: Find rows created before a given date
    • createdAfter: Find rows created after a given date
    • updatedBefore: Find rows updated before a given date
    • updatedAfter: Find rows updated after a given date

    That means you can:

    • Reduce boilerplate in your code
    • Write cleaner, more readable queries
    • Make time-based filtering faster and easier to manage

    Available now on Appwrite Cloud and Self-hosted.

    Read the announcement to learn more

  • JavaScript SDKs now use object arguments

    We've updated the Appwrite JavaScript SDKs to support object-based arguments instead of positional ones.

    This change makes SDK calls easier to read, less error-prone, and more maintainable.

    Before (positional arguments):

    JavaScript
    const result = storage.getFilePreview(
  '<BUCKET_ID>',
  '<FILE_ID>',
  undefined, // width
  undefined, // height
  ImageGravity.Center,
  undefined, // quality
  undefined, // borderWidth
  undefined, // borderColor
  undefined, // borderRadius
  undefined, // opacity
  undefined, // rotation
  undefined, // background
  ImageFormat.Jpg,
  '<TOKEN>'
);
// Required passing undefined for unused optional parameters

    After (object arguments):

    JavaScript
    const result = storage.getFilePreview({
  bucketId: '<BUCKET_ID>',
  fileId: '<FILE_ID>',
  gravity: ImageGravity.Center,
  output: ImageFormat.Jpg,
  token: '<TOKEN>'
});
// No more undefined values needed!
    What about existing code?

    Positional arguments still work, but they've been marked as deprecated. Your IDE will show warnings, and you can migrate over time.

    This update is now available in the following SDK versions:

    Join the discussion on Discord

  • Appwrite's new pricing goes into effect

    Starting today, September 1st, 2025, the following pricing changes will go into effect:

    • The base price for Pro will go from $15 to $25 per month
    • The per-seat pricing model is moving to a per-project pricing model
    • Resources will be per project instead of per organization, and we will be giving you more resources per project
    • The bandwidth resources on Pro and Scale go from 300GB to 2TB per month per project
    • The additional bandwidth price goes from $40 per 100GB to $15 per 100GB
    • The price for GB hours goes from $0.09 per GB hour to $0.06 per GB hour
    • The additional storage price goes from $3 per 100GB to $2.8 per 100GB
    • Appwrite Messaging and Sites now have resource limits on Free, Pro, and Scale plans

    Read the announcement to learn more

  • Email verification for Cloud accounts

    Appwrite Cloud will soon require email verification to enhance account authenticity. When we first launched the beta, we focused on streamlining onboarding by skipping this step, but as the platform grows, we’re committed to strengthening security and trust for all users.

    This change is aimed at:

    1. ensuring everyone has a valid email address for billing or support inquiries
    2. enhancing the overall security of our platform
    3. reducing the risk of spam or fraudulent accounts

    In preparation for this change, we encourage you and your team members to verify that your email addresses are correct and working so that you can complete the verification process when email verification becomes required.

    Check your account email

  • Announcing Opt-in relationship loading: Granular control for smarter data fetching

    Announcing Opt-in relationship loading for Appwrite Databases.

    Before this feature, database queries automatically included related documents. This often caused large JSON payloads, higher latency, and wasted bandwidth.

    With Opt-in relationship loading, you now choose exactly which related documents to include, resulting in smaller payloads and faster queries.

    This added control over data fetching helps you deliver faster, more efficient applications.

    Read the announcement to learn more

  • New Cloud region available: San Francisco (SFO)

    We’ve expanded the Appwrite Cloud to a brand-new region.

    Starting today, the San Francisco (SFO) region is now live and ready for your projects.

    This means you can:

    • Create new projects directly in SFO
    • Or migrate your existing projects to take advantage of the new location

    If your users are on the U.S. West Coast, the SFO region will help you deliver a faster and reliable experience to your users.

    Learn more about Regions

  • Announcing new TablesDB UI: A spreadsheet-like way to manage your data

    We’re excited to introduce a completely new TablesDB UI for Appwrite Databases

    Experience a spreadsheet‑like editing workflow, right inside the Console.

    You can now:

    • Edit records inline
    • Perform bulk actions
    • Navigate with arrow keys and shortcuts

    A faster way to patch production, clean up test data, and stay in flow.

    Read the announcement to learn more

Start building with Appwrite today

Get started

Our plans

  • Free

    $0

    A great fit for passion projects and small applications.

    Get started

  • Pro

    Most popular
    From
    $25
    /month

    For production applications that need powerful functionality and resources to scale.

    Start building

  • Enterprise

    Custom

    For enterprises that need more power and premium support.

    Contact us