diff --git a/src/routes/docs/+layout.svelte b/src/routes/docs/+layout.svelte
index 1d6fd677aa3..d6c671f7e22 100644
--- a/src/routes/docs/+layout.svelte
+++ b/src/routes/docs/+layout.svelte
@@ -4,12 +4,14 @@
 	import Sidebar from './Sidebar.svelte';
 
 	function getDocsVariant(pathname: string): DocsLayoutVariant {
+		const isSDKs = pathname.includes('/sdks');
+		const isAPIs = pathname.includes('/apis/');
 		const isTutorial = pathname.includes('/tutorials/');
 		const isQuickstart = pathname.includes('/quick-start/');
 		const isProduct = pathname.includes('/products/') || pathname.includes('/article');
 		const isReference = pathname.includes('/reference');
 
-		if (isTutorial || isProduct || isQuickstart) {
+		if (isTutorial || isProduct || isAPIs || isSDKs || isQuickstart) {
 			return 'two-side-navs';
 		} else if (isReference) {
 			return 'expanded';
diff --git a/src/routes/docs/Sidebar.svelte b/src/routes/docs/Sidebar.svelte
index cf68e50d5b6..97a092bb12a 100644
--- a/src/routes/docs/Sidebar.svelte
+++ b/src/routes/docs/Sidebar.svelte
@@ -46,7 +46,7 @@
 				},
 				{
 					label: 'SDKs',
-					href: '#',
+					href: '/docs/sdks',
 					icon: 'icon-cog'
 				},
 				{
@@ -253,17 +253,17 @@
 			items: [
 				{
 					label: 'Realtime',
-					href: '#',
+					href: '/docs/apis/realtime',
 					icon: 'icon-clock'
 				},
 				{
 					label: 'REST',
-					href: '#',
+					href: '/docs/apis/rest',
 					icon: 'icon-play'
 				},
 				{
 					label: 'GraphQL',
-					href: '#',
+					href: '/docs/apis/graphql',
 					icon: 'icon-play'
 				}
 			]
diff --git a/src/routes/docs/api/realtime/+page.markdoc b/src/routes/docs/api/realtime/+page.markdoc
deleted file mode 100644
index d9863be9f46..00000000000
--- a/src/routes/docs/api/realtime/+page.markdoc
+++ /dev/null
@@ -1,11 +0,0 @@
----
-layout: article
-title: Databases
-description: This is the description used for SEO.
----
-
-Appwrite Databases let you store and query structured data. 
-Databases provide high-performance and scalable data storage for your key application, business, and user data.
-
-## Explore capabilities {% #capabilities %}
-
diff --git a/src/routes/docs/apis/realtime/+page.markdoc b/src/routes/docs/apis/realtime/+page.markdoc
new file mode 100644
index 00000000000..4ac176e97ba
--- /dev/null
+++ b/src/routes/docs/apis/realtime/+page.markdoc
@@ -0,0 +1,514 @@
+---
+layout: article
+title: Realtime
+description: The Appwrite Realtime allows you to listen to any Appwrite events and build an interactive and responsive user experience.
+difficulty: beginner
+readtime: 10
+---
+
+Appwrite supports multiple protocols for accessing the server, including [REST](/docs/apis/rest), [GraphQL](/docs/apis/graphql), and [Realtime](/docs/apis/realtime). The Appwrite Realtime allows you to listen to any Appwrite events in realtime using the `subscribe` method.
+
+Instead of requesting new data via HTTP, the subscription will receive new data every time it changes, any connected client receives that update within milliseconds via a WebSocket connection.
+
+This lets you build an interactive and responsive user experience by providing information from all of Appwrite's services in realtime. The example below shows subscribing to realtime events for file uploads.
+
+{% multicode %}
+```js
+import { Client } from "appwrite";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+// Subscribe to files channel
+client.subscribe('files', response => {
+    if(response.events.includes('buckets.*.files.*.create')) {
+        // Log when a new file is uploaded
+        console.log(response.payload);
+    }
+});
+```
+
+```dart
+import 'package:appwrite/appwrite.dart';
+
+final client = Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+final realtime = Realtime(client);
+
+// Subscribe to files channel
+final subscription = realtime.subscribe(['files']);
+
+subscription.stream.listen((response) {
+    if(response.events.contains('buckets.*.files.*.create')) {
+    // Log when a new file is uploaded
+    print(response.payload);
+    }
+});
+```
+
+```swift
+import Appwrite
+import AppwriteModels
+
+let client = Client()
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+let realtime = Realtime(client)
+
+// Subscribe to files channel
+let subscription = realtime.subscribe(channels: ["files"]) { response in
+    if (message.events!.contains("buckets.*.files.*.create")) {
+        // Log when a new file is uploaded
+        print(String(describing: response))
+    }
+}
+```
+
+```java
+import io.appwrite.Client
+import io.appwrite.services.Realtime
+
+val client = Client(context)
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+val realtime = Realtime(client)
+
+// Subscribe to files channel
+let subscription = realtime.subscribe("files") {
+    if(it.events.contains("buckets.*.files.*.create")) {
+        // Log when a new file is uploaded
+        print(it.payload.toString());
+    }
+}
+```
+
+{% /multicode %}
+
+To subscribe to updates from different Appwrite resources, you need to specify one or more [channels](/docs/apis/realtime#channels). The channels offer a wide and powerful selection that will allow you to listen to all possible resources. This allows you to receive updates not only from the database, but from _all_ the services that Appwrite offers.
+
+If you subscribe to a channel, you will receive callbacks for a variety of events related to the channel. The events attribute in the callback can be used to filter and respond to specific events in a channel.
+
+[View a list of all available events](/docs/platform/events).
+
+
+{% info title="Permissions" %}
+All subscriptions are secured by the [permissions system](/docs/permissions) offered by Appwrite, meaning a user will only receive updates to resources they have permission to access.
+
+Using `Role.any()` on read permissions will allow any client to receive updates.
+{% /info %}
+
+## Authentication {% #authentication %}
+
+Realtime authenticates using an existing user session. If you authenticate **after** creating a subscription, the subscription will not receive updates for the newly authenticated user. You will need to re-create the subscription to work with the new user.
+
+More information and examples of authenticating users can be found in the dedicated [authentication docs](/docs/products/auth).
+
+## Examples {% #examples %}
+The examples below will show you how you can use Realtime in various ways.
+
+### Subscribe to a Channel
+In this example we are subscribing to all updates related to our account by using the `account` channel. This will be triggered by any update related to the authenticated user, like updating the user's name or e-mail address.
+
+{% multicode %}
+```js
+import { Client } from "appwrite";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+client.subscribe('account', response => {
+    // Callback will be executed on all account events.
+    console.log(response);
+});
+```
+
+```dart
+import 'package:appwrite/appwrite.dart';
+
+final client = Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+final realtime = Realtime(client);
+
+final subscription = realtime.subscribe(['account']);
+
+subscription.stream.listen((response) {
+    // Callback will be executed on all account events.
+    print(response);
+})
+```
+    
+```swift
+import Appwrite
+import AppwriteModels
+
+let client = Client()
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+let realtime = Realtime(client)
+
+let subscription = realtime.subscribe(channel: "account", callback: { response in
+    // Callback will be executed on all account events.
+    print(String(describing: response))
+})
+```
+
+```java
+import io.appwrite.Client
+import io.appwrite.services.Realtime
+
+val client = Client(context)
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+val realtime = Realtime(client)
+
+val subscription = realtime.subscribe("account") {
+    // Callback will be executed on all account events.
+    print(it.payload.toString())
+}
+```
+
+{% /multicode %}
+
+### Subscribe to Multiple Channels
+
+You can also listen to multiple channels at once by passing an array of channels. This will trigger the callback for any events for all channels passed.
+
+In this example we are listening to the document A and all files by subscribing to the `databases.A.collections.A.documents.A` and `files` channels.
+
+{% multicode %}
+```js
+import { Client } from "appwrite";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+client.subscribe(['collections.A.documents.A', 'files'], response => {
+    // Callback will be executed on changes for documents A and all files.
+    console.log(response);
+});
+```
+
+```dart
+import 'package:appwrite/appwrite.dart';
+
+final client = Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+final realtime = Realtime(client);
+
+final subscription = realtime.subscribe(['databases.A.collections.A.documents.A', 'files']);
+
+subscription.stream.listen((response) {
+    // Callback will be executed on changes for documents A and all files.
+    print(response);
+})
+```
+
+```swift
+import Appwrite
+import AppwriteModels
+
+let client = Client()
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+let realtime = Realtime(client)
+
+realtime.subscribe(channels: ["databases.A.collections.A.documents.A", "files"]) { response in
+    // Callback will be executed on changes for documents A and all files.
+    print(String(describing: response))
+}
+```
+
+```java
+import io.appwrite.Client
+import io.appwrite.services.Realtime
+
+val client = Client(context)
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+val realtime = Realtime(client)
+
+realtime.subscribe("databases.A.collections.A.documents.A", "files") {
+    // Callback will be executed on changes for documents A and all files.
+    print(it.toString())
+}
+```
+
+{% /multicode %}
+
+### Unsubscribe
+
+If you no longer want to receive updates from a subscription, you can unsubscribe so that your callbacks are no longer called. Leaving old subscriptions alive and resubscribing can result in duplicate subscriptions and cause race conditions.
+
+{% multicode %}
+```js
+import { Client } from "appwrite";
+
+const client = new Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+const unsubscribe = client.subscribe('files', response => {
+    // Callback will be executed on changes for all files.
+    console.log(response);
+});
+
+// Closes the subscription.
+unsubscribe();
+```
+
+```dart
+import 'package:appwrite/appwrite.dart';
+
+final client = Client()
+    .setEndpoint('https://cloud.appwrite.io/v1')
+    .setProject('[PROJECT_ID]');
+
+final realtime = Realtime(client);
+
+final subscription = realtime.subscribe(['files']);
+
+subscription.stream.listen((response) {
+    // Callback will be executed on changes for all files.
+    print(response);
+})
+
+// Closes the subscription.
+subscription.close();
+```
+
+```swift
+import Appwrite
+
+let client = Client()
+let realtime = Realtime(client)
+
+let subscription = realtime.subscribe(channel: "files") { response in
+    // Callback will be executed on changes for all files.
+    print(response.toString())
+}
+
+// Closes the subscription.
+subscription.close()
+```
+
+```java
+import io.appwrite.Client
+import io.appwrite.services.Realtime
+
+val client = Client(context)
+    .setEndpoint("https://cloud.appwrite.io/v1")
+    .setProject("[PROJECT_ID]")
+
+val realtime = Realtime(client)
+
+val subscription = realtime.subscribe("files") {
+    // Callback will be executed on changes for all files.
+    print(param.toString())
+}
+
+// Closes the subscription.
+subscription.close()
+```
+
+{% /multicode %}
+
+## Payload {% #payload %}
+
+The payload from the subscription will contain following properties:
+
+{% table %}
+* Name
+* Type
+* Description
+---
+* events
+* string[]
+* The [system events](/docs/platform/events) that triggered this update.
+---
+* channels
+* string[]
+* An array of [channels](/docs/apis/realtime#channels) that can receive this message.
+---
+* timestamp
+* string
+* The [ISO 8601 timestamp](https://en.wikipedia.org/wiki/ISO_8601) in UTC timezone from the server 
+---
+* payload
+* object
+* Payload contains the data equal to the response model.
+{% /table %}
+
+If you subscribe to the `documents` channel and a document the user is allowed to read is updated, you will receive an object containing information about the event and the updated document.
+
+The response will look like this:
+
+```json
+{
+  "events": [
+    "databases.default.collections.sample.documents.63c98b9baea0938e1206.update",
+    "databases.*.collections.*.documents.*.update",
+    "databases.default.collections.*.documents.63c98b9baea0938e1206.update",
+    "databases.*.collections.*.documents.63c98b9baea0938e1206.update",
+    "databases.*.collections.sample.documents.63c98b9baea0938e1206.update",
+    "databases.default.collections.sample.documents.*.update",
+    "databases.*.collections.sample.documents.*.update",
+    "databases.default.collections.*.documents.*.update",
+    "databases.default.collections.sample.documents.63c98b9baea0938e1206",
+    "databases.*.collections.*.documents.*",
+    "databases.default.collections.*.documents.63c98b9baea0938e1206",
+    "databases.*.collections.*.documents.63c98b9baea0938e1206",
+    "databases.*.collections.sample.documents.63c98b9baea0938e1206",
+    "databases.default.collections.sample.documents.*",
+    "databases.*.collections.sample.documents.*",
+    "databases.default.collections.*.documents.*",
+    "databases.default.collections.sample",
+    "databases.*.collections.*",
+    "databases.default.collections.*",
+    "databases.*.collections.sample",
+    "databases.default",
+    "databases.*"
+  ],
+  "channels": [
+    "documents",
+    "databases.default.collections.sample.documents",
+    "databases.default.collections.sample.documents.63c98b9baea0938e1206"
+  ],
+  "timestamp": "2023-01-19 18:30:04.051",
+  "payload": {
+    "ip": "127.0.0.1",
+    "stringArray": [
+      "sss"
+    ],
+    "email": "joe@example.com",
+    "stringRequired": "req",
+    "float": 3.3,
+    "boolean": false,
+    "integer": 3,
+    "enum": "apple",
+    "stringDefault": "default",
+    "datetime": "2023-01-19T10:27:09.428+00:00",
+    "url": "https://appwrite.io",
+    "$id": "63c98b9baea0938e1206",
+    "$createdAt": "2023-01-19T18:27:39.715+00:00",
+    "$updatedAt": "2023-01-19T18:30:04.040+00:00",
+    "$permissions": [],
+    "$collectionId": "sample",
+    "$databaseId": "default"
+  }
+}
+```
+
+## Channels {% #channels %}
+
+A list of all channels available you can subscribe to. IDs cannot be wildcards.
+
+{% table %}
+* Channel
+* Description
+---
+* `account`
+* All account related events (session create, name update...)
+---
+* `databases.[ID].collections.[ID].documents`
+* Any create/update/delete events to any document in a collection
+---
+* `documents`
+* Any create/update/delete events to any document
+---
+* `databases.[ID].collections.[ID].documents.[ID]`
+* Any update/delete events to a given document
+---
+* `files`
+* Any create/update/delete events to any file
+---
+* `buckets.[ID].files.[ID]`
+* Any update/delete events to a given file of the given bucket
+---
+* `buckets.[ID].files`
+* Any update/delete events to any file of the given bucket
+---
+* `teams`
+* Any create/update/delete events to a any team
+---
+* `teams.[ID]`
+* Any update/delete events to a given team
+---
+* `memberships`
+* Any create/update/delete events to a any membership
+---
+* `memberships.[ID]`
+* Any update/delete events to a given membership
+---
+* `executions`
+* Any update to executions
+---
+* `executions.[ID]`
+* Any update to a given execution
+---
+* `functions.[ID]`
+* Any execution event to a given function
+
+{% /table %}
+
+## Custom endpoint {% #custom-endpoint %}
+
+The SDK will guess the endpoint of the Realtime API when setting the endpoint of your Appwrite instance. If you are running Appwrite with a custom proxy and changed the route of the Realtime API, you can call the `setEndpointRealtime` method on the Client SDK and set your new endpoint value.
+
+By default the endpoint is `wss://cloud.appwrite.io/v1/realtime`.
+
+{% multicode %}
+```js
+import { Client } from "appwrite";
+const client = new Client();
+
+client.setEndpointRealtime('wss://cloud.appwrite.io/v1/realtime');
+```
+
+```dart
+import 'package:appwrite/appwrite.dart';
+
+final client = Client();
+client.setEndpointRealtime('wss://cloud.appwrite.io/v1/realtime');
+```
+
+```swift
+import Appwrite
+
+let client = Client()
+client.setEndpointRealtime("wss://cloud.appwrite.io/v1/realtime")
+```
+
+```java
+import io.appwrite.Client
+
+val client = Client(context)
+client.setEndpointRealtime("wss://cloud.appwrite.io/v1/realtime")
+```
+
+{% /multicode %}
+
+## Limitations {% #limitations %}
+
+While the Realtime API offers robust capabilities, there are currently some limitations to be aware of in its implementation.
+
+### Subscriptions changes
+
+The SDK creates a single WebSocket connection for all subscribed channels. Each time a channel is added or unsubscribed - the SDK currently creates a completely new connection and terminates the old one. Therefore, subscriptions to channels should always be done in conjunction with state management so as not to be unnecessarily built up several times by multiple components' life cycles.
+
+### Server-side SDKs
+
+We currently are not offering access to realtime with Server SDKs and an API key.
\ No newline at end of file
diff --git a/src/routes/docs/apis/rest/+page.markdoc b/src/routes/docs/apis/rest/+page.markdoc
new file mode 100644
index 00000000000..5144b9a7d86
--- /dev/null
+++ b/src/routes/docs/apis/rest/+page.markdoc
@@ -0,0 +1,176 @@
+---
+layout: article
+title: REST
+description: 
+difficulty: beginner
+readtime: 10
+---
+
+Appwrite supports multiple protocols for accessing the server, including [REST](/docs/apis/rest), [GraphQL](/docs/apis/graphql), and [Realtime](/docs/apis/realtime). The REST API allows you to access your Appwrite server through HTTP requests without the needing an SDK. Each endpoint in the API represents a specific operation on a specific resource.
+
+## Headers {% #headers %}
+
+Appwrite's REST APIs expect certain headers to be included with each request:
+
+{% table %}
+* Header
+* 
+* Description
+---
+* `X-Appwrite-Project: [PROJECT-ID]`
+* required
+* The ID of your Appwrite project
+---
+* `Content-Type: application/json`
+* required
+* Content type of the HTTP request. Would usually be `application/json`.
+---
+* `X-Appwrite-Key: [API-KEY]`
+* optional
+* API key used for server authentication. Your API key is a secret, **do not** use it in client applications.
+---
+* `X-Appwrite-JWT: [TOKEN]`
+* optional
+* Token used for JWT authentication, tokens can be generated using the [Create JWT](/docs/products/auth/jwt) method.
+---
+* `X-Appwrite-Response-Format: [VERSION-NUMBER]`
+* optional
+* Version number used for backward compatibility. The response will be formatted to be compatible with the provided version number. This helps Appwrite SDKs keep backward compatibility with Appwrite server API version.
+---
+* `X-Fallback-Cookies: [FALLBACK-COOKIES]`
+* optional
+* Fallback cookies used in scenarios where browsers do not allow third-party cookies. Often used when there is no Custom Domain set for your Appwrite API.
+---
+{% /table %}
+
+## Authentication {% #authentication %}
+
+### Client side
+
+You can create account sessions with POST requests to the Account API. Sessions are persisted using secured cookies. You can learn more about session persistence in the Authentication Guide.
+
+The example below shows creating an account session with the Create Account Session with Email endpoint.
+
+```json
+POST /v1/account/sessions/email HTTP/1.1
+Content-Type: application/json
+X-Appwrite-Project: [PROJECT_ID]
+
+{
+  "email": "example@email.com",
+  "password": "password"
+}
+```
+
+You can find the cookies used to persist the new session in the response headers.
+
+```json
+Set-Cookie: a_session_61e71ec784ab035f7259_legacy=eyJ0...aSJ9; expires=Tue, 19-Dec-2023 21:26:51 GMT; path=/; domain=.cloud.appwrite.io; secure; httponly
+Set-Cookie: a_session_61e71ec784ab035f7259=eyJ0...aSJ9; expires=Tue, 19-Dec-2023 21:26:51 GMT; path=/; domain=.cloud.appwrite.io; secure; httponly; samesite=None
+```
+
+These cookies are used in subsequent requests to authenticate the user.
+
+```json
+GET /v1/account HTTP/1.1
+Cookie: a_session_61e71ec784ab035f7259_legacy=eyJ0...aSJ9; a_session_61e71ec784ab035f7259=eyJ0...aSJ9
+Content-Type: application/json
+X-Appwrite-Project: [PROJECT_ID]
+```
+
+### Server side
+
+Server integrations use API keys to authenticate and are typically used for backend applications.
+
+Server APIs are authenticated with API keys instead of account sessions. Simply pass an [API key](/docs/platform/api-keys) in the `X-Appwrite-key: [API-KEY]` header with the appropriate scopes.
+
+```json
+GET /v1/databases/{databaseId}/collections/{collectionId}/documents HTTP/1.1
+Content-Type: application/json
+X-Appwrite-Project: [PROJECT_ID]
+X-Appwrite-Key: [API_KEY]
+```
+
+### JWT
+
+JWT authentication is frequently used by server applications to act on behalf of a user. Users generate tokens using the [Create JWT](/todo) endpoint. When issuing requests authenticated with a JWT, Appwrite will treat the request like it is from the authenticated user.
+
+```json
+GET /v1/account HTTP/1.1
+Content-Type: application/json
+X-Appwrite-Project: [PROJECT_ID]
+X-Appwrite-JWT: [TOKEN]
+```
+
+## Files {% #files %}
+
+Appwrite implements resumable, chunked uploads for files larger than 5MB. Chunked uploads send files in chunks of 5MB to reduce memory footprint and increase resilience when handling large files. Appwrite SDKs will automatically handle chunked uploads, but it is possible to implement this with the REST API directly.
+
+Upload endpoints in Appwrite, such as [Create File](todo) and [Create Deployment](todo), are different from other endpoints. These endpoints take multipart form data instead of JSON data. To implement chunked uploads, you will need to implement the following headers. If you wish, this logic is already available in any of the [Appwrite SDKs](/docs/sdks).
+
+{% table %}
+* Header
+* 
+* Description
+---
+* `X-Appwrite-Project: [PROJECT-ID]`
+* required
+* The ID of your Appwrite project
+---
+* `Content-Type: multipart/form-data; boundary=[FORM-BOUNDARY]`
+* required
+* Contains the content type of the HTTP request and provides a [boundary](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) that is used to parse the form data.
+---
+* `Content-Range: bytes [BYTE-RANGE]`
+* required
+* Contains information about which bytes are being transmitted in this chunk, with the format `[FIRST-BYTE]-[LAST-BYTE]/[TOTAL-BYTES]`.
+---
+* `X-Appwrite-ID: [FILE-ID]`
+* required
+* Contains ID of the file this chunk belongs to.
+---
+* `X-Appwrite-Key: [API-KEY]`
+* optional
+* API key used for server authentication. Your API key is a secret, **do not** use it in client applications.
+
+{% /table %}
+
+## Images {% #images %}
+
+Some use cases do not allow custom headers, such as embedding images from Appwrite in HTML. In these cases, you can provide the Appwrite project ID using the query parameter project.
+
+```HTML
+<img src="[ENDPOINT]/v1/storage/buckets/[BUCKET_ID]/files/[FILE_ID]/preview?project=[PROJECT_ID]"/>
+```
+
+## Permissions {% #permissions %}
+
+### Roles
+
+## Unique ID {% #unique-id %}
+
+Appwrite's SDKs have a helper `ID.unique()` to generate unique IDs. When using Appwrite without an SDK, pass the string `"unique()"` into the ID parameter.
+
+## Queries {% #queries %}
+
+Appwrite's SDKs provide a `Query` class to generate query strings. When using Appwrite without an SDK, you can template your own strings with the format below.
+
+Query strings are passed to Appwrite using the `queries` parameter. You can attach multiple query strings by including the array parameter multiple times in the query string: `queries[]="..."&queries[]="..."`
+
+{% info title="Best practice" %}
+When using greater than, greater than or equal to, less than, or less than or equal to, it is not recommended to pass in multiple values. While the API will accept multiple values and return results with or logic, it's best practice to pass in only one value for performance reasons.
+
+{% /info %}
+
+
+## Rate limits {% #rate-limits %}
+
+Appwrite's REST APIs are protected by the same rate limit policies, just like when using an SDK. Each API has a different rate limit, which is documented in the References section of each service in the Appwrite documentation.
+
+[Learn more about Rate Limits](/docs/platform/rate-limits).
+
+## Specifications {% #specifications %}
+
+Appwrite provides a full REST API specification in the OpenAPI 3 and Swagger 2 formats every release. These can be accessed through Appwrite's GitHub repository and rendered using a variety of parsers and tools.
+
+[Find the REST API specification for your Appwrite version](https://github.com/appwrite/appwrite/tree/master/app/config/specs).
\ No newline at end of file
diff --git a/src/routes/docs/sdks/+page.markdoc b/src/routes/docs/sdks/+page.markdoc
new file mode 100644
index 00000000000..93c14fdfebf
--- /dev/null
+++ b/src/routes/docs/sdks/+page.markdoc
@@ -0,0 +1,96 @@
+---
+layout: article
+title: SDKs
+description: Learn how to integrate Appwrite in your application with one of the supported SDKs.
+---
+
+Appwrite provides SDK libraries for major programming languages and platforms so you don't have to write code for interacting with our API protocols from scratch.
+
+We're always working on improving and extending the current stack of available platforms and SDKs, listed below is a list of official libraries the Appwrite team is maintaining.
+
+## Client Side {% #client-side %}
+
+Client libraries for integrating with Appwrite to build client-based applications and websites. Read one of the many [quick start](/docs/quick-start) guides for your framework of choice to start building your first application.
+
+{% table %}
+* {% align="center" %}
+* Platform
+* GitHub Repository {% style="width:10px" %}
+---
+* x {% align="center" %}
+* Web SDK `13.0.0`
+* [appwrite/sdk-for-web](https://github.com/appwrite/sdk-for-web)
+---
+* ![Flutter](https://appwrite.io/images-ee/platforms/flutter.svg)
+* Flutter SDK `11.0.0`
+* [appwrite/sdk-for-flutter](https://github.com/appwrite/sdk-for-flutter)
+---
+* x
+* Apple SDK `4.0.0`
+* [appwrite/sdk-for-apple](https://github.com/appwrite/sdk-for-apple)
+---
+* x
+* Android SDK `4.0.0`
+* [appwrite/sdk-for-android](https://github.com/appwrite/sdk-for-android)
+{% /table %}
+
+## Server Side {% #server-side %}
+
+Server libraries for integrating with Appwrite to build server side integrations or use inside your [Appwrite Functions](/docs/products/functions). Read one of the many [quick start](/docs/quick-start) guides for your language/runtime of choice to start building your first server integration.
+
+{% table %}
+* {% align="center" %}
+* Platform
+* GitHub Repository {% style="width:10px" %}
+---
+* x {% align="center" %}
+* Node.js SDK `11.0.0`
+* [appwrite/sdk-for-node](https://github.com/appwrite/sdk-for-node)
+---
+* x {% align="center" %}
+* Dart SDK `10.0.0`
+* [appwrite/sdk-for-dart](https://github.com/appwrite/sdk-for-dart)
+---
+* x {% align="center" %}
+* Python SDK `4.0.0`
+* [appwrite/sdk-for-python](https://github.com/appwrite/sdk-for-python)
+---
+* x {% align="center" %}
+* PHP SDK `10.0.0`
+* [appwrite/sdk-for-php](https://github.com/appwrite/sdk-for-php)
+---
+* x {% align="center" %}
+* Ruby SDK `10.0.0`
+* [appwrite/sdk-for-ruby](https://github.com/appwrite/sdk-for-ruby)
+---
+* x {% align="center" %}
+* .NET SDK `0.6.0`
+* [appwrite/sdk-for-dotnet](https://github.com/appwrite/sdk-for-dotnet)
+---
+* x {% align="center" %}
+* Deno SDK `9.0.0`
+* [appwrite/sdk-for-deno](https://github.com/appwrite/sdk-for-deno)
+---
+* x {% align="center" %}
+* Kotlin SDK `4.0.0`
+* [appwrite/sdk-for-kotlin](https://github.com/appwrite/sdk-for-kotlin)
+---
+* x {% align="center" %}
+* Swift SDK `4.0.0`
+* [appwrite/sdk-for-swift](https://github.com/appwrite/sdk-for-swift)
+{% /table %}
+
+If you would like to help us extend our platforms and SDKs stack, you are more than welcome to contact us or check out our Appwrite SDK Generator project GitHub repository and read our contribution guide.
+
+## Protocols {% #protocols %}
+We are always looking to add new SDKs to our platform. If the SDK you are looking for is still missing, labeled as beta or experimental, or you simply do not want to integrate with an SDK, you can always integrate with Appwrite directly using any standard HTTP, GraphQL, or WebSocket clients and the relevant Appwrite protocol.
+
+Appwrite supports multiple API protocols for maximum flexibility and developer convenience. You can learn more about how to integrate directly with them using one of the following available guides:
+- [Integrate with the Appwrite REST API](/docs/protocols/rest)
+- [Integrate with the Appwrite GraphQL API](/docs/protocols/graphql)
+- [Integrate with the Appwrite Realtime API](/docs/protocols/realtime)
+
+## Community {% #community %}
+If you have created your own framework or any other technology specific integration and would like us to list it here please [contact us](/contact-us).
+
+If you would like to help us extend the Appwrite SDKs stack, you are more than welcome to check out the Appwrite [SDK Generator](https://github.com/appwrite/sdk-generator) project on GitHub and read our [contribution guide](https://github.com/appwrite/sdk-generator/blob/master/CONTRIBUTING.md).
\ No newline at end of file
