What is the Appwrite Projects API?

It is a set of endpoints on the `Project` service that let you configure and read a project's settings programmatically from any Appwrite Server SDK. Previously, settings like auth methods, OAuth providers, and SMTP could only be changed through the Appwrite Console.

What can I configure with the Projects API?

Auth methods, OAuth2 providers, API keys, platforms, protocols, services, password and session policies, environment variables, custom SMTP, email templates, mock phone numbers, and project labels. You can also read the full project configuration with `project.get`.

What does the Projects API require?

An API key with the relevant scopes. Reading the project uses `project.read`, most configuration uses `project.write`, and some resources have dedicated scopes such as `platforms.write`, `templates.write`, or `keys.write`. These keys are server-side credentials, so keep them out of client applications.

How is the Projects API different from the Console?

It exposes the same project settings as the Console through code. Anything you configure by clicking through the Console you can now script, version, and review, which makes project setup repeatable across environments.

Which SDKs support the Projects API?

All Appwrite Server SDKs, including Node.js, Python, PHP, Ruby, .NET, Dart, Kotlin, Java, Swift, Go, and Rust, along with the Appwrite CLI. Per-language examples are in the [Projects API documentation](/docs/partners/project).

Can I create a project with the Projects API?

The Projects API manages the settings of an existing project and reads it with `project.get`. Creating a project still happens in the Appwrite Console.

Announcing the Projects API: Configure your project with Server SDKs_

Every project setting, from auth methods and OAuth providers to SMTP and labels, can now be configured programmatically through the Appwrite Server SDKs.

Matej Bačo

Engineering Lead

Jul 22, 20265 min read

Configuring a project has always meant working through the Appwrite Console: toggling auth methods, pasting OAuth credentials, registering platforms, and setting up SMTP one screen at a time. For a single project, that is fine. For teams managing several environments, onboarding new projects, or rebuilding a configuration from scratch, repeating those steps by hand becomes a bottleneck.

Today, we are announcing the Projects API, which lets you configure and read every project setting programmatically through the Appwrite Server SDKs.

This is part of a wider effort to make everything in Appwrite accessible through the API. Our goal is to ensure that any action you can perform in the Appwrite Console can also be done programmatically, giving you full control over your projects through code.

Why this matters

A project's configuration is the foundation every other resource sits on. Which auth methods are enabled, which platforms can connect, how email is delivered: these decisions shape how your app behaves. This matters most for partners: agencies, consultancies, and platforms that manage Appwrite projects on behalf of their clients, where every new client means another project to set up and keep consistent. Managing configuration from code opens up workflows that were previously manual:

Reproducible environments where development, staging, and production projects are configured from the same script
Project provisioning that sets up auth, platforms, and policies for a new project in one run
Multi-tenant platforms that configure a project per customer without Console access
Partner workflows, where agencies, consultancies, and other teams that build for clients provision and manage projects at scale without clicking through the Console for each one
Configuration in version control, so changes to a project are reviewed and tracked like any other code

What you can configure

The Projects API covers the full surface of project settings, grouped into a few areas:

Authentication: enable or disable auth methods, configure OAuth2 providers, and set password and session policies.
Access: create and manage API keys, register platforms, and toggle protocols and services.
Email: configure a custom SMTP server, customize email templates, and send test emails.
Project: manage environment variables, register mock phone numbers for testing, assign labels, and read the full configuration with project.get.

How it works

Every operation lives on the Project service. Initialize a Server SDK with an API key, then call the settings you need. For example, registering a web platform that is allowed to call your project:

Node.js

import { Client, Project, ID } from 'node-appwrite';

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

const project = new Project(client);

const result = await project.createWebPlatform({
    platformId: ID.unique(),
    name: 'My Web App',
    hostname: 'app.example.com'
});

import { Client, Project, ID } from "npm:node-appwrite";

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

const project = new Project(client);

const result = await project.createWebPlatform({
    platformId: ID.unique(),
    name: 'My Web App',
    hostname: 'app.example.com'
});

<?php

use Appwrite\Client;
use Appwrite\ID;
use Appwrite\Services\Project;

$client = new Client();

$client
    ->setEndpoint('https://<REGION>.cloud.appwrite.io/v1')
    ->setProject('<PROJECT_ID>')
    ->setKey('<YOUR_API_KEY>');

$project = new Project($client);

$result = $project->createWebPlatform(
    platformId: ID::unique(),
    name: 'My Web App',
    hostname: 'app.example.com'
);

from appwrite.client import Client
from appwrite.id import ID
from appwrite.services.project import Project

client = Client()
client.set_endpoint('https://<REGION>.cloud.appwrite.io/v1')
client.set_project('<PROJECT_ID>')
client.set_key('<YOUR_API_KEY>')

project = Project(client)

result = project.create_web_platform(
    platform_id = ID.unique(),
    name = 'My Web App',
    hostname = 'app.example.com'
)

require 'appwrite'

include Appwrite

client = Client.new
    .set_endpoint('https://<REGION>.cloud.appwrite.io/v1')
    .set_project('<PROJECT_ID>')
    .set_key('<YOUR_API_KEY>')

project = Project.new(client)

response = project.create_web_platform(
    platform_id: ID.unique(),
    name: 'My Web App',
    hostname: 'app.example.com'
)

using Appwrite;
using Appwrite.Services;

Client client = new Client()
    .SetEndPoint("https://<REGION>.cloud.appwrite.io/v1")
    .SetProject("<PROJECT_ID>")
    .SetKey("<YOUR_API_KEY>");

Project project = new Project(client);

var result = await project.CreateWebPlatform(
    platformId: ID.Unique(),
    name: "My Web App",
    hostname: "app.example.com"
);

import 'package:dart_appwrite/dart_appwrite.dart';

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

Project project = Project(client);

final result = await project.createWebPlatform(
    platformId: ID.unique(),
    name: 'My Web App',
    hostname: 'app.example.com',
);

import io.appwrite.Client
import io.appwrite.ID
import io.appwrite.services.Project

val client = Client()
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")
    .setKey("<YOUR_API_KEY>")

val project = Project(client)

val response = project.createWebPlatform(
    platformId = ID.unique(),
    name = "My Web App",
    hostname = "app.example.com"
)

import io.appwrite.Client;
import io.appwrite.ID;
import io.appwrite.coroutines.CoroutineCallback;
import io.appwrite.services.Project;

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

Project project = new Project(client);

project.createWebPlatform(
    ID.unique(), // platformId
    "My Web App", // name
    "app.example.com", // hostname
    new CoroutineCallback<>((result, error) -> {
        if (error != null) {
            error.printStackTrace();
            return;
        }
        System.out.println(result);
    })
);

import Appwrite

let client = Client()
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")
    .setKey("<YOUR_API_KEY>")

let project = Project(client)

let result = try await project.createWebPlatform(
    platformId: ID.unique(),
    name: "My Web App",
    hostname: "app.example.com"
)

package main

import (
    "fmt"
    "github.com/appwrite/sdk-for-go/appwrite"
    "github.com/appwrite/sdk-for-go/id"
)

func main() {
    client := appwrite.NewClient(
        appwrite.WithEndpoint("https://<REGION>.cloud.appwrite.io/v1"),
        appwrite.WithProject("<PROJECT_ID>"),
        appwrite.WithKey("<YOUR_API_KEY>"),
    )

    project := appwrite.NewProject(client)
    result, err := project.CreateWebPlatform(
        id.Unique(),
        "My Web App",
        "app.example.com",
    )

    if err != nil {
        panic(err)
    }

    fmt.Println(result)
}

use appwrite::Client;
use appwrite::id::ID;
use appwrite::services::Project;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    client.set_endpoint("https://<REGION>.cloud.appwrite.io/v1");
    client.set_project("<PROJECT_ID>");
    client.set_key("<YOUR_API_KEY>");

    let project = Project::new(&client);

    let result = project.create_web_platform(
        ID::unique(),
        "My Web App",
        "app.example.com",
    ).await?;

    let _ = result;

    Ok(())
}

Or controlling which API protocols clients can use to reach your project, for example enabling REST:

Node.js

import { Client, Project, ProjectProtocolId } from 'node-appwrite';

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

const project = new Project(client);

const result = await project.updateProtocol({
    protocolId: ProjectProtocolId.Rest,
    enabled: true
});

import { Client, Project, ProjectProtocolId } from "npm:node-appwrite";

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

const project = new Project(client);

const result = await project.updateProtocol({
    protocolId: ProjectProtocolId.Rest,
    enabled: true
});

<?php

use Appwrite\Client;
use Appwrite\Enums\ProjectProtocolId;
use Appwrite\Services\Project;

$client = new Client();

$client
    ->setEndpoint('https://<REGION>.cloud.appwrite.io/v1')
    ->setProject('<PROJECT_ID>')
    ->setKey('<YOUR_API_KEY>');

$project = new Project($client);

$result = $project->updateProtocol(
    protocolId: ProjectProtocolId::REST(),
    enabled: true
);

from appwrite.client import Client
from appwrite.enums import ProjectProtocolId
from appwrite.services.project import Project

client = Client()
client.set_endpoint('https://<REGION>.cloud.appwrite.io/v1')
client.set_project('<PROJECT_ID>')
client.set_key('<YOUR_API_KEY>')

project = Project(client)

result = project.update_protocol(
    protocol_id = ProjectProtocolId.REST,
    enabled = True
)

require 'appwrite'

include Appwrite
include Appwrite::Enums

client = Client.new
    .set_endpoint('https://<REGION>.cloud.appwrite.io/v1')
    .set_project('<PROJECT_ID>')
    .set_key('<YOUR_API_KEY>')

project = Project.new(client)

response = project.update_protocol(
    protocol_id: ProjectProtocolId::REST,
    enabled: true
)

using Appwrite;
using Appwrite.Enums;
using Appwrite.Services;

Client client = new Client()
    .SetEndPoint("https://<REGION>.cloud.appwrite.io/v1")
    .SetProject("<PROJECT_ID>")
    .SetKey("<YOUR_API_KEY>");

Project project = new Project(client);

var result = await project.UpdateProtocol(
    protocolId: ProjectProtocolId.Rest,
    enabled: true
);

import 'package:dart_appwrite/dart_appwrite.dart';
import 'package:dart_appwrite/enums.dart' as enums;

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

Project project = Project(client);

final result = await project.updateProtocol(
    protocolId: enums.ProjectProtocolId.rest,
    enabled: true,
);

import io.appwrite.Client
import io.appwrite.enums.ProjectProtocolId
import io.appwrite.services.Project

val client = Client()
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")
    .setKey("<YOUR_API_KEY>")

val project = Project(client)

val response = project.updateProtocol(
    protocolId = ProjectProtocolId.REST,
    enabled = true
)

import io.appwrite.Client;
import io.appwrite.enums.ProjectProtocolId;
import io.appwrite.coroutines.CoroutineCallback;
import io.appwrite.services.Project;

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

Project project = new Project(client);

project.updateProtocol(
    ProjectProtocolId.REST, // protocolId
    true, // enabled
    new CoroutineCallback<>((result, error) -> {
        if (error != null) {
            error.printStackTrace();
            return;
        }
        System.out.println(result);
    })
);

import Appwrite
import AppwriteEnums

let client = Client()
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")
    .setKey("<YOUR_API_KEY>")

let project = Project(client)

let result = try await project.updateProtocol(
    protocolId: .rest,
    enabled: true
)

package main

import (
    "fmt"
    "github.com/appwrite/sdk-for-go/appwrite"
)

func main() {
    client := appwrite.NewClient(
        appwrite.WithEndpoint("https://<REGION>.cloud.appwrite.io/v1"),
        appwrite.WithProject("<PROJECT_ID>"),
        appwrite.WithKey("<YOUR_API_KEY>"),
    )

    project := appwrite.NewProject(client)
    result, err := project.UpdateProtocol(
        "rest",
        true,
    )

    if err != nil {
        panic(err)
    }

    fmt.Println(result)
}

use appwrite::Client;
use appwrite::services::Project;
use appwrite::enums::ProjectProtocolId;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    client.set_endpoint("https://<REGION>.cloud.appwrite.io/v1");
    client.set_project("<PROJECT_ID>");
    client.set_key("<YOUR_API_KEY>");

    let project = Project::new(&client);

    let result = project.update_protocol(
        ProjectProtocolId::Rest,
        true
    ).await?;

    let _ = result;

    Ok(())
}

Every setting maps to a method on the Project service, available across all Server SDKs with the matching object or named parameters.

Get started

The Projects API is available on Appwrite Cloud today, across all Appwrite Server SDKs, including Node.js, Python, PHP, Ruby, .NET, Dart, Kotlin, Java, Swift, Go, and Rust, as well as the Appwrite CLI.

Create an API key with the scopes for the settings you want to manage.
Initialize a Server SDK with your API key.
Use the Project service to configure your project from code.

Resources

Projects API documentation

Appwrite Discord community

Announcing the Projects API: Configure your project with Server SDKs_

Why this matters

What you can configure

How it works

Get started

Resources

Frequently asked questions

Read next

Add Google One Tap sign-in to your web app with Appwrite

Announcing user photos: A profile picture for every user

Announcing native sign-in: Create Appwrite sessions from Apple and Google ID tokens

Announcing one-click Resend setup in the Appwrite Console

PostgreSQL, MySQL, and dedicated databases are now available across all regions

Introducing the official Appwrite plugin for ChatGPT

Ready to build?_